src/third_party/icu/source/test/cintltst/usrchtst.c

   1 /********************************************************************
   2  * Copyright (c) 2001-2011 International Business Machines
   3  * Corporation and others. All Rights Reserved.
   4  ********************************************************************
   5  * File usrchtst.c
   6  * Modification History:
   7  * Name           Date             Description
   8  * synwee         July 19 2001     creation
   9  ********************************************************************/
  10
  11 #include "unicode/utypes.h"
  12
  13 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO
  14
  15 #include "unicode/usearch.h"
  16 #include "unicode/ustring.h"
  17 #include "ccolltst.h"
  18 #include "cmemory.h"
  19 #include <stdio.h>
  20 #include "usrchdat.c"
  21 #include "unicode/ubrk.h"
  22 #include <assert.h>
  23
  24 static UBool      TOCLOSE_ = TRUE;
  25 static UCollator *EN_US_;
  26 static UCollator *FR_FR_;
  27 static UCollator *DE_;
  28 static UCollator *ES_;
  29
  30 /**
  31  * CHECK_BREAK(char *brk)
  32  *     Test if a break iterator is passed in AND break iteration is disabled.
  33  *     Skip the test if so.
  34  * CHECK_BREAK_BOOL(char *brk)
  35  *     Same as above, but returns 'TRUE' as a passing result
  36  */
  37
  38 #if !UCONFIG_NO_BREAK_ITERATION
  39 static UBreakIterator *EN_WORDBREAKER_;
  40 static UBreakIterator *EN_CHARACTERBREAKER_;
  41 #define CHECK_BREAK(x)
  42 #define CHECK_BREAK_BOOL(x)
  43 #else
  44 #define CHECK_BREAK(x)  if(x) { log_info("Skipping test on %s:%d because UCONFIG_NO_BREAK_ITERATION is on\n", __FILE__, __LINE__); return; }
  45 #define CHECK_BREAK_BOOL(x)  if(x) { log_info("Skipping test on %s:%d because UCONFIG_NO_BREAK_ITERATION is on\n", __FILE__, __LINE__); return TRUE; }
  46 #endif
  47
  48 /**
  49 * Opening all static collators and break iterators
  50 */
  51 static void open(UErrorCode* status)
  52 {
  53     if (TOCLOSE_) {
  54         UChar      rules[1024];
  55         int32_t    rulelength = 0;
  56         *status = U_ZERO_ERROR;
  57
  58         EN_US_ = ucol_open("en_US", status);
  59         if(U_FAILURE(*status)) {
  60           log_err_status(*status, "Error opening collator\n");
  61           return;
  62         }
  63         FR_FR_ = ucol_open("fr_FR", status);
  64         DE_ = ucol_open("de_DE", status);
  65         ES_ = ucol_open("es_ES", status);
  66
  67         u_strcpy(rules, ucol_getRules(DE_, &rulelength));
  68         u_unescape(EXTRACOLLATIONRULE, rules + rulelength, 1024 - rulelength);
  69
  70         ucol_close(DE_);
  71
  72         DE_ = ucol_openRules(rules, u_strlen(rules), UCOL_ON, UCOL_TERTIARY,
  73                              (UParseError *)NULL, status);
  74         u_strcpy(rules, ucol_getRules(ES_, &rulelength));
  75         u_unescape(EXTRACOLLATIONRULE, rules + rulelength, 1024 - rulelength);
  76
  77         ucol_close(ES_);
  78         ES_ = ucol_openRules(rules, u_strlen(rules), UCOL_ON, UCOL_TERTIARY,
  79                              NULL, status);
  80 #if !UCONFIG_NO_BREAK_ITERATION
  81         EN_WORDBREAKER_     = ubrk_open(UBRK_WORD, "en_US", NULL, 0, status);
  82         EN_CHARACTERBREAKER_ = ubrk_open(UBRK_CHARACTER, "en_US", NULL, 0,
  83                                         status);
  84 #endif
  85         TOCLOSE_ = TRUE;
  86     }
  87 }
  88
  89 /**
  90 * Start opening all static collators and break iterators
  91 */
  92 static void TestStart(void)
  93 {
  94     UErrorCode status = U_ZERO_ERROR;
  95     open(&status);
  96     if (U_FAILURE(status)) {
  97         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
  98         return;
  99     }
 100     TOCLOSE_ = FALSE;
 101 }
 102
 103 /**
 104 * Closing all static collators and break iterators
 105 */
 106 static void close(void)
 107 {
 108     if (TOCLOSE_) {
 109         ucol_close(EN_US_);
 110         ucol_close(FR_FR_);
 111         ucol_close(DE_);
 112         ucol_close(ES_);
 113 #if !UCONFIG_NO_BREAK_ITERATION
 114         ubrk_close(EN_WORDBREAKER_);
 115         ubrk_close(EN_CHARACTERBREAKER_);
 116 #endif
 117     }
 118     TOCLOSE_ = FALSE;
 119 }
 120
 121 /**
 122 * End closing all static collators and break iterators
 123 */
 124 static void TestEnd(void)
 125 {
 126     TOCLOSE_ = TRUE;
 127     close();
 128     TOCLOSE_ = TRUE;
 129 }
 130
 131 /**
 132 * output UChar strings for printing.
 133 */
 134 static char *toCharString(const UChar* unichars)
 135 {
 136     static char result[1024];
 137     char *temp   = result;
 138     int   count  = 0;
 139     int   length = u_strlen(unichars);
 140
 141     for (; count < length; count ++) {
 142         UChar ch = unichars[count];
 143         if (ch >= 0x20 && ch <= 0x7e) {
 144             *temp ++ = (char)ch;
 145         }
 146         else {
 147             sprintf(temp, "\\u%04x", ch);
 148             temp += 6; /* \uxxxx */
 149         }
 150     }
 151     *temp = 0;
 152
 153     return result;
 154 }
 155
 156 /**
 157 * Getting the collator
 158 */
 159 static UCollator *getCollator(const char *collator)
 160 {
 161     if (collator == NULL) {
 162         return EN_US_;
 163     }
 164     if (strcmp(collator, "fr") == 0) {
 165         return FR_FR_;
 166     }
 167     else if (strcmp(collator, "de") == 0) {
 168         return DE_;
 169     }
 170     else if (strcmp(collator, "es") == 0) {
 171         return ES_;
 172     }
 173     else {
 174         return EN_US_;
 175     }
 176 }
 177
 178 /**
 179 * Getting the breakiterator
 180 */
 181 static UBreakIterator *getBreakIterator(const char *breaker)
 182 {
 183     if (breaker == NULL) {
 184         return NULL;
 185     }
 186 #if !UCONFIG_NO_BREAK_ITERATION
 187     if (strcmp(breaker, "wordbreaker") == 0) {
 188         return EN_WORDBREAKER_;
 189     }
 190     else {
 191         return EN_CHARACTERBREAKER_;
 192     }
 193 #else
 194     return NULL;
 195 #endif
 196 }
 197
 198 static void TestOpenClose(void)
 199 {
 200           UErrorCode      status    = U_ZERO_ERROR;
 201           UStringSearch  *result;
 202     const UChar           pattern[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
 203     const UChar           text[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67};
 204 #if !UCONFIG_NO_BREAK_ITERATION
 205           UBreakIterator *breakiter = ubrk_open(UBRK_WORD, "en_US",
 206                                                 text, 6, &status);
 207 #endif
 208     /* testing null arguments */
 209     result = usearch_open(NULL, 0, NULL, 0, NULL, NULL, &status);
 210     if (U_SUCCESS(status) || result != NULL) {
 211         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 212     }
 213     status = U_ZERO_ERROR;
 214     result = usearch_openFromCollator(NULL, 0, NULL, 0, NULL, NULL, &status);
 215     if (U_SUCCESS(status) || result != NULL) {
 216         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 217     }
 218
 219     status = U_ZERO_ERROR;
 220     result = usearch_open(pattern, 3, NULL, 0, NULL, NULL, &status);
 221     if (U_SUCCESS(status) || result != NULL) {
 222         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 223     }
 224     status = U_ZERO_ERROR;
 225     result = usearch_openFromCollator(pattern, 3, NULL, 0, NULL, NULL,
 226                                       &status);
 227     if (U_SUCCESS(status) || result != NULL) {
 228         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 229     }
 230
 231     status = U_ZERO_ERROR;
 232     result = usearch_open(pattern, 3, text, 6, NULL, NULL, &status);
 233     if (U_SUCCESS(status) || result != NULL) {
 234         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 235     }
 236     status = U_ZERO_ERROR;
 237     result = usearch_openFromCollator(pattern, 3, text, 6, NULL, NULL,
 238                                       &status);
 239     if (U_SUCCESS(status) || result != NULL) {
 240         log_err("Error: NULL arguments should produce an error and a NULL result\n");
 241     }
 242
 243     status = U_ZERO_ERROR;
 244     result = usearch_open(pattern, 3, text, 6, "en_US", NULL, &status);
 245     if (U_FAILURE(status) || result == NULL) {
 246         log_err_status(status, "Error: NULL break iterator is valid for opening search\n");
 247     }
 248     else {
 249         usearch_close(result);
 250     }
 251     open(&status);
 252     if (U_FAILURE(status)) {
 253         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 254         return;
 255     }
 256     status = U_ZERO_ERROR;
 257     result = usearch_openFromCollator(pattern, 3, text, 6, EN_US_, NULL,
 258                                       &status);
 259     if (U_FAILURE(status) || result == NULL) {
 260         if (EN_US_ == NULL) {
 261             log_data_err("Opening collator failed.\n");
 262         } else {
 263             log_err("Error: NULL break iterator is valid for opening search\n");
 264         }
 265     }
 266     else {
 267         usearch_close(result);
 268     }
 269
 270
 271     status = U_ZERO_ERROR;
 272 #if !UCONFIG_NO_BREAK_ITERATION
 273
 274     result = usearch_open(pattern, 3, text, 6, "en_US", breakiter, &status);
 275     if (U_FAILURE(status) || result == NULL) {
 276         log_err_status(status, "Error: Break iterator is valid for opening search\n");
 277     }
 278     else {
 279         usearch_close(result);
 280     }
 281     status = U_ZERO_ERROR;
 282     result = usearch_openFromCollator(pattern, 3, text, 6, EN_US_, breakiter,
 283                                       &status);
 284     if (U_FAILURE(status) || result == NULL) {
 285         if (EN_US_ == NULL) {
 286             log_data_err("Opening collator failed.\n");
 287         } else {
 288             log_err("Error: Break iterator is valid for opening search\n");
 289         }
 290     }
 291     else {
 292         usearch_close(result);
 293     }
 294     ubrk_close(breakiter);
 295 #endif
 296     close();
 297 }
 298
 299 static void TestInitialization(void)
 300 {
 301           UErrorCode      status = U_ZERO_ERROR;
 302           UChar           pattern[512];
 303     const UChar           text[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
 304     int32_t i = 0;
 305     UStringSearch  *result;
 306
 307     /* simple test on the pattern ce construction */
 308     pattern[0] = 0x41;
 309     pattern[1] = 0x42;
 310     open(&status);
 311     if (U_FAILURE(status)) {
 312         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 313         return;
 314     }
 315     result = usearch_openFromCollator(pattern, 2, text, 3, EN_US_, NULL,
 316                                       &status);
 317     if (U_FAILURE(status)) {
 318         log_err("Error opening search %s\n", u_errorName(status));
 319     }
 320     usearch_close(result);
 321
 322     /* testing if an extremely large pattern will fail the initialization */
 323     for(i = 0; i < 512; i++) {
 324       pattern[i] = 0x41;
 325     }
 326     /*uprv_memset(pattern, 0x41, 512);*/
 327     result = usearch_openFromCollator(pattern, 512, text, 3, EN_US_, NULL,
 328                                       &status);
 329     if (U_FAILURE(status)) {
 330         log_err("Error opening search %s\n", u_errorName(status));
 331     }
 332     usearch_close(result);
 333     close();
 334 }
 335
 336 static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
 337                                           const SearchData     search)
 338 {
 339     int         count       = 0;
 340     UErrorCode  status      = U_ZERO_ERROR;
 341     int32_t matchindex  = search.offset[count];
 342     int32_t     textlength;
 343     UChar       matchtext[128];
 344     int32_t     matchlength;
 345     int32_t     nextStart;
 346     UBool       isOverlap;
 347
 348     usearch_setAttribute(strsrch, USEARCH_ELEMENT_COMPARISON, search.elemCompare, &status);
 349     if (U_FAILURE(status)) {
 350         log_err("Error setting USEARCH_ELEMENT_COMPARISON attribute %s\n", u_errorName(status));
 351         return FALSE;
 352     }
 353
 354     if (usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
 355         usearch_getMatchedLength(strsrch) != 0) {
 356         log_err("Error with the initialization of match start and length\n");
 357     }
 358     /* start of next matches */
 359     while (U_SUCCESS(status) && matchindex >= 0) {
 360         matchlength = search.size[count];
 361         usearch_next(strsrch, &status);
 362         if (matchindex != usearch_getMatchedStart(strsrch) ||
 363             matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
 364             char *str = toCharString(usearch_getText(strsrch, &textlength));
 365             log_err("Text: %s\n", str);
 366             str = toCharString(usearch_getPattern(strsrch, &textlength));
 367             log_err("Pattern: %s\n", str);
 368             log_err("Error next match found at idx %d (len:%d); expected %d (len:%d)\n",
 369                     usearch_getMatchedStart(strsrch), usearch_getMatchedLength(strsrch),
 370                     matchindex, matchlength);
 371             return FALSE;
 372         }
 373         count ++;
 374
 375         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
 376             (int32_t) matchlength || U_FAILURE(status) ||
 377             memcmp(matchtext,
 378                    usearch_getText(strsrch, &textlength) + matchindex,
 379                    matchlength * sizeof(UChar)) != 0) {
 380             log_err("Error getting next matched text\n");
 381         }
 382
 383         matchindex = search.offset[count];
 384     }
 385     usearch_next(strsrch, &status);
 386     if (usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
 387         usearch_getMatchedLength(strsrch) != 0) {
 388         char *str = toCharString(usearch_getText(strsrch, &textlength));
 389         log_err("Text: %s\n", str);
 390         str = toCharString(usearch_getPattern(strsrch, &textlength));
 391         log_err("Pattern: %s\n", str);
 392         log_err("Error next match found at %d (len:%d); expected <NO MATCH>\n",
 393                     usearch_getMatchedStart(strsrch),
 394                     usearch_getMatchedLength(strsrch));
 395         return FALSE;
 396     }
 397     /* start of previous matches */
 398     count = count == 0 ? 0 : count - 1;
 399     matchindex = search.offset[count];
 400
 401     while (U_SUCCESS(status) && matchindex >= 0) {
 402         matchlength = search.size[count];
 403         usearch_previous(strsrch, &status);
 404         if (matchindex != usearch_getMatchedStart(strsrch) ||
 405             matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
 406             char *str = toCharString(usearch_getText(strsrch, &textlength));
 407             log_err("Text: %s\n", str);
 408             str = toCharString(usearch_getPattern(strsrch, &textlength));
 409             log_err("Pattern: %s\n", str);
 410             log_err("Error previous match found at %d (len:%d); expected %d (len:%d)\n",
 411                     usearch_getMatchedStart(strsrch), usearch_getMatchedLength(strsrch),
 412                     matchindex, matchlength);
 413             return FALSE;
 414         }
 415
 416         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
 417             (int32_t) matchlength || U_FAILURE(status) ||
 418             memcmp(matchtext,
 419                    usearch_getText(strsrch, &textlength) + matchindex,
 420                    matchlength * sizeof(UChar)) != 0) {
 421             log_err("Error getting previous matched text\n");
 422         }
 423
 424         matchindex = count > 0 ? search.offset[count - 1] : -1;
 425         count --;
 426     }
 427     usearch_previous(strsrch, &status);
 428     if (usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
 429         usearch_getMatchedLength(strsrch) != 0) {
 430         char *str = toCharString(usearch_getText(strsrch, &textlength));
 431         log_err("Text: %s\n", str);
 432         str = toCharString(usearch_getPattern(strsrch, &textlength));
 433         log_err("Pattern: %s\n", str);
 434         log_err("Error previous match found at %d (len:%d); expected <NO MATCH>\n",
 435                     usearch_getMatchedStart(strsrch),
 436                     usearch_getMatchedLength(strsrch));
 437         return FALSE;
 438     }
 439
 440
 441     isOverlap = (usearch_getAttribute(strsrch, USEARCH_OVERLAP) == USEARCH_ON);
 442
 443     /* start of following matches */
 444     count = 0;
 445     matchindex  = search.offset[count];
 446     nextStart = 0;
 447
 448     while (TRUE) {
 449         usearch_following(strsrch, nextStart, &status);
 450
 451         if (matchindex < 0) {
 452             if (usearch_getMatchedStart(strsrch) != USEARCH_DONE || usearch_getMatchedLength(strsrch) != 0) {
 453                 char *str = toCharString(usearch_getText(strsrch, &textlength));
 454                 log_err("Text: %s\n", str);
 455                 str = toCharString(usearch_getPattern(strsrch, &textlength));
 456                 log_err("Pattern: %s\n", str);
 457                 log_err("Error following match starting at %d (overlap:%d) found at %d (len:%d); expected <NO MATCH>\n",
 458                             nextStart, isOverlap,
 459                             usearch_getMatchedStart(strsrch),
 460                             usearch_getMatchedLength(strsrch));
 461                 return FALSE;
 462             }
 463             /* no more matches */
 464             break;
 465         }
 466
 467         matchlength = search.size[count];
 468         if (usearch_getMatchedStart(strsrch) != matchindex
 469                 || usearch_getMatchedLength(strsrch) != matchlength
 470                 || U_FAILURE(status)) {
 471             char *str = toCharString(usearch_getText(strsrch, &textlength));
 472             log_err("Text: %s\n", str);
 473             str = toCharString(usearch_getPattern(strsrch, &textlength));
 474             log_err("Pattern: %s\n", str);
 475             log_err("Error following match starting at %d (overlap: %d) found at %d (len:%d); expected %d (len:%d)\n",
 476                         nextStart, isOverlap,
 477                         usearch_getMatchedStart(strsrch), usearch_getMatchedLength(strsrch),
 478                         matchindex, matchlength);
 479             return FALSE;
 480         }
 481
 482         if (isOverlap || usearch_getMatchedLength(strsrch) == 0) {
 483             nextStart = usearch_getMatchedStart(strsrch) + 1;
 484         } else {
 485             nextStart = usearch_getMatchedStart(strsrch) + usearch_getMatchedLength(strsrch);
 486         }
 487
 488         count++;
 489         matchindex = search.offset[count];
 490     }
 491
 492     /* start of preceding matches */
 493     count = -1; /* last non-negative offset index, could be -1 if no match */
 494     while (search.offset[count + 1] >= 0) {
 495         count++;
 496     }
 497     usearch_getText(strsrch, &nextStart);
 498
 499     while (TRUE) {
 500         usearch_preceding(strsrch, nextStart, &status);
 501
 502         if (count < 0) {
 503             if (usearch_getMatchedStart(strsrch) != USEARCH_DONE || usearch_getMatchedLength(strsrch) != 0) {
 504                 char *str = toCharString(usearch_getText(strsrch, &textlength));
 505                 log_err("Text: %s\n", str);
 506                 str = toCharString(usearch_getPattern(strsrch, &textlength));
 507                 log_err("Pattern: %s\n", str);
 508                 log_err("Error preceding match starting at %d (overlap: %d) found at %d (len:%d); expected <NO MATCH>\n",
 509                             nextStart, isOverlap,
 510                             usearch_getMatchedStart(strsrch),
 511                             usearch_getMatchedLength(strsrch));
 512                 return FALSE;
 513             }
 514             /* no more matches */
 515             break;
 516         }
 517
 518         matchindex = search.offset[count];
 519         matchlength = search.size[count];
 520         if (usearch_getMatchedStart(strsrch) != matchindex
 521                 || usearch_getMatchedLength(strsrch) != matchlength
 522                 || U_FAILURE(status)) {
 523             char *str = toCharString(usearch_getText(strsrch, &textlength));
 524             log_err("Text: %s\n", str);
 525             str = toCharString(usearch_getPattern(strsrch, &textlength));
 526             log_err("Pattern: %s\n", str);
 527             log_err("Error preceding match starting at %d (overlap: %d) found at %d (len:%d); expected %d (len:%d)\n",
 528                         nextStart, isOverlap,
 529                         usearch_getMatchedStart(strsrch), usearch_getMatchedLength(strsrch),
 530                         matchindex, matchlength);
 531             return FALSE;
 532         }
 533
 534         nextStart = matchindex;
 535         count--;
 536     }
 537
 538     usearch_setAttribute(strsrch, USEARCH_ELEMENT_COMPARISON, USEARCH_STANDARD_ELEMENT_COMPARISON, &status);
 539     return TRUE;
 540 }
 541
 542 static UBool assertEqual(const SearchData search)
 543 {
 544     UErrorCode      status      = U_ZERO_ERROR;
 545     UChar           pattern[32];
 546     UChar           text[128];
 547     UCollator      *collator = getCollator(search.collator);
 548     UBreakIterator *breaker  = getBreakIterator(search.breaker);
 549     UStringSearch  *strsrch;
 550
 551     CHECK_BREAK_BOOL(search.breaker);
 552
 553     u_unescape(search.text, text, 128);
 554     u_unescape(search.pattern, pattern, 32);
 555     ucol_setStrength(collator, search.strength);
 556     strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
 557                                        breaker, &status);
 558     if (U_FAILURE(status)) {
 559         log_err("Error opening string search %s\n", u_errorName(status));
 560         return FALSE;
 561     }
 562
 563     if (!assertEqualWithUStringSearch(strsrch, search)) {
 564         ucol_setStrength(collator, UCOL_TERTIARY);
 565         usearch_close(strsrch);
 566         return FALSE;
 567     }
 568     ucol_setStrength(collator, UCOL_TERTIARY);
 569     usearch_close(strsrch);
 570     return TRUE;
 571 }
 572
 573 static UBool assertCanonicalEqual(const SearchData search)
 574 {
 575     UErrorCode      status      = U_ZERO_ERROR;
 576     UChar           pattern[32];
 577     UChar           text[128];
 578     UCollator      *collator = getCollator(search.collator);
 579     UBreakIterator *breaker  = getBreakIterator(search.breaker);
 580     UStringSearch  *strsrch;
 581     UBool           result = TRUE;
 582
 583     CHECK_BREAK_BOOL(search.breaker);
 584     u_unescape(search.text, text, 128);
 585     u_unescape(search.pattern, pattern, 32);
 586     ucol_setStrength(collator, search.strength);
 587     ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 588     strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
 589                                        breaker, &status);
 590     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
 591                          &status);
 592     if (U_FAILURE(status)) {
 593         log_err("Error opening string search %s\n", u_errorName(status));
 594         result = FALSE;
 595         goto bail;
 596     }
 597
 598     if (!assertEqualWithUStringSearch(strsrch, search)) {
 599         ucol_setStrength(collator, UCOL_TERTIARY);
 600         usearch_close(strsrch);
 601         result = FALSE;
 602         goto bail;
 603     }
 604
 605 bail:
 606     ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
 607     ucol_setStrength(collator, UCOL_TERTIARY);
 608     usearch_close(strsrch);
 609     return result;
 610 }
 611
 612 static UBool assertEqualWithAttribute(const SearchData            search,
 613                                             USearchAttributeValue canonical,
 614                                             USearchAttributeValue overlap)
 615 {
 616     UErrorCode      status      = U_ZERO_ERROR;
 617     UChar           pattern[32];
 618     UChar           text[128];
 619     UCollator      *collator = getCollator(search.collator);
 620     UBreakIterator *breaker  = getBreakIterator(search.breaker);
 621     UStringSearch  *strsrch;
 622
 623     CHECK_BREAK_BOOL(search.breaker);
 624     u_unescape(search.text, text, 128);
 625     u_unescape(search.pattern, pattern, 32);
 626     ucol_setStrength(collator, search.strength);
 627     strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
 628                                        breaker, &status);
 629     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, canonical,
 630                          &status);
 631     usearch_setAttribute(strsrch, USEARCH_OVERLAP, overlap, &status);
 632
 633     if (U_FAILURE(status)) {
 634         log_err("Error opening string search %s\n", u_errorName(status));
 635         return FALSE;
 636     }
 637
 638     if (!assertEqualWithUStringSearch(strsrch, search)) {
 639             ucol_setStrength(collator, UCOL_TERTIARY);
 640             usearch_close(strsrch);
 641             return FALSE;
 642     }
 643     ucol_setStrength(collator, UCOL_TERTIARY);
 644     usearch_close(strsrch);
 645     return TRUE;
 646 }
 647
 648 static void TestBasic(void)
 649 {
 650     int count = 0;
 651     UErrorCode status = U_ZERO_ERROR;
 652     open(&status);
 653     if (U_FAILURE(status)) {
 654         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 655         return;
 656     }
 657     while (BASIC[count].text != NULL) {
 658         if (!assertEqual(BASIC[count])) {
 659             log_err("Error at test number %d\n", count);
 660         }
 661         count ++;
 662     }
 663     close();
 664 }
 665
 666 static void TestNormExact(void)
 667 {
 668     int count = 0;
 669     UErrorCode status = U_ZERO_ERROR;
 670     open(&status);
 671     if (U_FAILURE(status)) {
 672         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 673         return;
 674     }
 675     ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 676     if (U_FAILURE(status)) {
 677         log_err("Error setting collation normalization %s\n",
 678             u_errorName(status));
 679     }
 680     while (BASIC[count].text != NULL) {
 681         if (!assertEqual(BASIC[count])) {
 682             log_err("Error at test number %d\n", count);
 683         }
 684         count ++;
 685     }
 686     count = 0;
 687     while (NORMEXACT[count].text != NULL) {
 688         if (!assertEqual(NORMEXACT[count])) {
 689             log_err("Error at test number %d\n", count);
 690         }
 691         count ++;
 692     }
 693     ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
 694     count = 0;
 695     while (NONNORMEXACT[count].text != NULL) {
 696         if (!assertEqual(NONNORMEXACT[count])) {
 697             log_err("Error at test number %d\n", count);
 698         }
 699         count ++;
 700     }
 701     close();
 702 }
 703
 704 static void TestStrength(void)
 705 {
 706     int count = 0;
 707     UErrorCode status = U_ZERO_ERROR;
 708     open(&status);
 709     if (U_FAILURE(status)) {
 710         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 711         return;
 712     }
 713     while (STRENGTH[count].text != NULL) {
 714         if (!assertEqual(STRENGTH[count])) {
 715             log_err("Error at test number %d\n", count);
 716         }
 717         count ++;
 718     }
 719     close();
 720 }
 721
 722 static void TestBreakIterator(void) {
 723     UErrorCode      status      = U_ZERO_ERROR;
 724     UStringSearch  *strsrch;
 725     UChar           text[128];
 726     UChar           pattern[32];
 727     int             count = 0;
 728
 729     CHECK_BREAK("x");
 730
 731 #if !UCONFIG_NO_BREAK_ITERATION
 732     open(&status);
 733     if (U_FAILURE(status)) {
 734         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 735         return;
 736     }
 737     if (usearch_getBreakIterator(NULL) != NULL) {
 738         log_err("Expected NULL breakiterator from NULL string search\n");
 739     }
 740     u_unescape(BREAKITERATOREXACT[0].text, text, 128);
 741     u_unescape(BREAKITERATOREXACT[0].pattern, pattern, 32);
 742     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, NULL,
 743                                        &status);
 744     if (U_FAILURE(status)) {
 745         log_err("Error opening string search %s\n", u_errorName(status));
 746         goto ENDTESTBREAKITERATOR;
 747     }
 748
 749     usearch_setBreakIterator(strsrch, NULL, &status);
 750     if (U_FAILURE(status) || usearch_getBreakIterator(strsrch) != NULL) {
 751         log_err("Error usearch_getBreakIterator returned wrong object");
 752         goto ENDTESTBREAKITERATOR;
 753     }
 754
 755     usearch_setBreakIterator(strsrch, EN_CHARACTERBREAKER_, &status);
 756     if (U_FAILURE(status) ||
 757         usearch_getBreakIterator(strsrch) != EN_CHARACTERBREAKER_) {
 758         log_err("Error usearch_getBreakIterator returned wrong object");
 759         goto ENDTESTBREAKITERATOR;
 760     }
 761
 762     usearch_setBreakIterator(strsrch, EN_WORDBREAKER_, &status);
 763     if (U_FAILURE(status) ||
 764         usearch_getBreakIterator(strsrch) != EN_WORDBREAKER_) {
 765         log_err("Error usearch_getBreakIterator returned wrong object");
 766         goto ENDTESTBREAKITERATOR;
 767     }
 768
 769     usearch_close(strsrch);
 770
 771     count = 0;
 772     while (count < 4) {
 773         /* 0-3 test are fixed */
 774         const SearchData     *search   = &(BREAKITERATOREXACT[count]);
 775               UCollator      *collator = getCollator(search->collator);
 776               UBreakIterator *breaker  = getBreakIterator(search->breaker);
 777
 778         u_unescape(search->text, text, 128);
 779         u_unescape(search->pattern, pattern, 32);
 780         ucol_setStrength(collator, search->strength);
 781
 782         strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
 783                                            breaker, &status);
 784         if (U_FAILURE(status) ||
 785             usearch_getBreakIterator(strsrch) != breaker) {
 786             log_err("Error setting break iterator\n");
 787             if (strsrch != NULL) {
 788                 usearch_close(strsrch);
 789             }
 790         }
 791         if (!assertEqualWithUStringSearch(strsrch, *search)) {
 792             ucol_setStrength(collator, UCOL_TERTIARY);
 793             usearch_close(strsrch);
 794             goto ENDTESTBREAKITERATOR;
 795         }
 796         search   = &(BREAKITERATOREXACT[count + 1]);
 797         breaker  = getBreakIterator(search->breaker);
 798         usearch_setBreakIterator(strsrch, breaker, &status);
 799         if (U_FAILURE(status) || usearch_getBreakIterator(strsrch) != breaker) {
 800             log_err("Error setting break iterator\n");
 801             usearch_close(strsrch);
 802             goto ENDTESTBREAKITERATOR;
 803         }
 804         usearch_reset(strsrch);
 805         if (!assertEqualWithUStringSearch(strsrch, *search)) {
 806             log_err("Error at test number %d\n", count);
 807             usearch_close(strsrch);
 808             goto ENDTESTBREAKITERATOR;
 809         }
 810         usearch_close(strsrch);
 811         count += 2;
 812     }
 813     count = 0;
 814     while (BREAKITERATOREXACT[count].text != NULL) {
 815          if (!assertEqual(BREAKITERATOREXACT[count])) {
 816              log_err("Error at test number %d\n", count);
 817              goto ENDTESTBREAKITERATOR;
 818          }
 819          count ++;
 820     }
 821
 822 ENDTESTBREAKITERATOR:
 823     close();
 824 #endif
 825 }
 826
 827 static void TestVariable(void)
 828 {
 829     int count = 0;
 830     UErrorCode status = U_ZERO_ERROR;
 831     open(&status);
 832     if (U_FAILURE(status)) {
 833         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 834         return;
 835     }
 836     ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
 837     if (U_FAILURE(status)) {
 838         log_err("Error setting collation alternate attribute %s\n",
 839             u_errorName(status));
 840     }
 841     while (VARIABLE[count].text != NULL) {
 842         log_verbose("variable %d\n", count);
 843         if (!assertEqual(VARIABLE[count])) {
 844             log_err("Error at test number %d\n", count);
 845         }
 846         count ++;
 847     }
 848     ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING,
 849                       UCOL_NON_IGNORABLE, &status);
 850     close();
 851 }
 852
 853 static void TestOverlap(void)
 854 {
 855     int count = 0;
 856     UErrorCode status = U_ZERO_ERROR;
 857     open(&status);
 858     if (U_FAILURE(status)) {
 859         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
 860         return;
 861     }
 862     while (OVERLAP[count].text != NULL) {
 863         if (!assertEqualWithAttribute(OVERLAP[count], USEARCH_OFF,
 864                                       USEARCH_ON)) {
 865             log_err("Error at overlap test number %d\n", count);
 866         }
 867         count ++;
 868     }
 869     count = 0;
 870     while (NONOVERLAP[count].text != NULL) {
 871         if (!assertEqual(NONOVERLAP[count])) {
 872             log_err("Error at non overlap test number %d\n", count);
 873         }
 874         count ++;
 875     }
 876
 877     count = 0;
 878     while (count < 1) {
 879               UChar           pattern[32];
 880               UChar           text[128];
 881         const SearchData     *search   = &(OVERLAP[count]);
 882               UCollator      *collator = getCollator(search->collator);
 883               UStringSearch  *strsrch;
 884               status   = U_ZERO_ERROR;
 885
 886         u_unescape(search->text, text, 128);
 887         u_unescape(search->pattern, pattern, 32);
 888         strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
 889                                            NULL, &status);
 890         if(status == U_FILE_ACCESS_ERROR) {
 891           log_data_err("Is your data around?\n");
 892           return;
 893         } else if(U_FAILURE(status)) {
 894           log_err("Error opening searcher\n");
 895           return;
 896         }
 897         usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
 898         if (U_FAILURE(status) ||
 899             usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
 900             log_err("Error setting overlap option\n");
 901         }
 902         if (!assertEqualWithUStringSearch(strsrch, *search)) {
 903             usearch_close(strsrch);
 904             return;
 905         }
 906         search   = &(NONOVERLAP[count]);
 907         usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
 908         if (U_FAILURE(status) ||
 909             usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
 910             log_err("Error setting overlap option\n");
 911         }
 912         usearch_reset(strsrch);
 913         if (!assertEqualWithUStringSearch(strsrch, *search)) {
 914             usearch_close(strsrch);
 915             log_err("Error at test number %d\n", count);
 916          }
 917
 918         count ++;
 919         usearch_close(strsrch);
 920     }
 921     close();
 922 }
 923
 924 static void TestCollator(void)
 925 {
 926     /* test collator that thinks "o" and "p" are the same thing */
 927           UChar          rules[32];
 928           UCollator     *tailored = NULL;
 929           UErrorCode     status   = U_ZERO_ERROR;
 930           UChar          pattern[32];
 931           UChar          text[128];
 932           UStringSearch *strsrch;
 933
 934     text[0] = 0x41;
 935     text[1] = 0x42;
 936     text[2] = 0x43;
 937     text[3] = 0x44;
 938     text[4] = 0x45;
 939     pattern[0] = 0x62;
 940     pattern[1] = 0x63;
 941     strsrch  = usearch_open(pattern, 2, text, 5, "en_US",  NULL,  &status);
 942     if(status == U_FILE_ACCESS_ERROR) {
 943       log_data_err("Is your data around?\n");
 944       return;
 945     } else if(U_FAILURE(status)) {
 946       log_err("Error opening searcher\n");
 947       return;
 948     }
 949     tailored = usearch_getCollator(strsrch);
 950     if (usearch_next(strsrch, &status) != -1) {
 951         log_err("Error: Found case insensitive match, when we shouldn't\n");
 952     }
 953     ucol_setStrength(tailored, UCOL_PRIMARY);
 954     usearch_reset(strsrch);
 955     if (usearch_next(strsrch, &status) != 1) {
 956         log_err("Error: Found case insensitive match not found\n");
 957     }
 958     usearch_close(strsrch);
 959
 960     open(&status);
 961
 962     if (usearch_getCollator(NULL) != NULL) {
 963         log_err("Expected NULL collator from NULL string search\n");
 964     }
 965     u_unescape(COLLATOR[0].text, text, 128);
 966     u_unescape(COLLATOR[0].pattern, pattern, 32);
 967
 968     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
 969                                        NULL, &status);
 970     if (U_FAILURE(status)) {
 971         log_err("Error opening string search %s\n", u_errorName(status));
 972     }
 973     if (!assertEqualWithUStringSearch(strsrch, COLLATOR[0])) {
 974         goto ENDTESTCOLLATOR;
 975     }
 976
 977     u_unescape(TESTCOLLATORRULE, rules, 32);
 978     tailored = ucol_openRules(rules, -1, UCOL_ON, COLLATOR[1].strength,
 979                               NULL, &status);
 980     if (U_FAILURE(status)) {
 981         log_err("Error opening rule based collator %s\n", u_errorName(status));
 982     }
 983
 984     usearch_setCollator(strsrch, tailored, &status);
 985     if (U_FAILURE(status) || usearch_getCollator(strsrch) != tailored) {
 986         log_err("Error setting rule based collator\n");
 987     }
 988     usearch_reset(strsrch);
 989     if (!assertEqualWithUStringSearch(strsrch, COLLATOR[1])) {
 990         goto ENDTESTCOLLATOR;
 991     }
 992
 993     usearch_setCollator(strsrch, EN_US_, &status);
 994     usearch_reset(strsrch);
 995     if (U_FAILURE(status) || usearch_getCollator(strsrch) != EN_US_) {
 996         log_err("Error setting rule based collator\n");
 997     }
 998     if (!assertEqualWithUStringSearch(strsrch, COLLATOR[0])) {
 999         goto ENDTESTCOLLATOR;
1000     }
1001
1002 ENDTESTCOLLATOR:
1003     usearch_close(strsrch);
1004     if (tailored != NULL) {
1005         ucol_close(tailored);
1006     }
1007     close();
1008 }
1009
1010 static void TestPattern(void)
1011 {
1012           UStringSearch *strsrch;
1013           UChar          pattern[32];
1014           UChar          bigpattern[512];
1015           UChar          text[128];
1016     const UChar         *temp;
1017           int32_t        templength;
1018           UErrorCode     status = U_ZERO_ERROR;
1019
1020     open(&status);
1021     if (U_FAILURE(status)) {
1022         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1023         return;
1024     }
1025     if (usearch_getPattern(NULL, &templength) != NULL) {
1026         log_err("Error NULL string search expected returning NULL pattern\n");
1027     }
1028     usearch_setPattern(NULL, pattern, 3, &status);
1029     if (U_SUCCESS(status)) {
1030         log_err("Error expected setting pattern in NULL strings search\n");
1031     }
1032     status = U_ZERO_ERROR;
1033     u_unescape(PATTERN[0].text, text, 128);
1034     u_unescape(PATTERN[0].pattern, pattern, 32);
1035
1036     ucol_setStrength(EN_US_, PATTERN[0].strength);
1037     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
1038                                        NULL, &status);
1039     if(status == U_FILE_ACCESS_ERROR) {
1040       log_data_err("Is your data around?\n");
1041       return;
1042     } else if(U_FAILURE(status)) {
1043       log_err("Error opening searcher\n");
1044       return;
1045     }
1046
1047     status = U_ZERO_ERROR;
1048     usearch_setPattern(strsrch, NULL, 3, &status);
1049     if (U_SUCCESS(status)) {
1050         log_err("Error expected setting NULL pattern in strings search\n");
1051     }
1052     status = U_ZERO_ERROR;
1053     usearch_setPattern(strsrch, pattern, 0, &status);
1054     if (U_SUCCESS(status)) {
1055         log_err("Error expected setting pattern with length 0 in strings search\n");
1056     }
1057     status = U_ZERO_ERROR;
1058     if (U_FAILURE(status)) {
1059         log_err("Error opening string search %s\n", u_errorName(status));
1060         goto ENDTESTPATTERN;
1061     }
1062     temp = usearch_getPattern(strsrch, &templength);
1063     if (u_strcmp(pattern, temp) != 0) {
1064         log_err("Error setting pattern\n");
1065     }
1066     if (!assertEqualWithUStringSearch(strsrch, PATTERN[0])) {
1067         goto ENDTESTPATTERN;
1068     }
1069
1070     u_unescape(PATTERN[1].pattern, pattern, 32);
1071     usearch_setPattern(strsrch, pattern, -1, &status);
1072     temp = usearch_getPattern(strsrch, &templength);
1073     if (u_strcmp(pattern, temp) != 0) {
1074         log_err("Error setting pattern\n");
1075         goto ENDTESTPATTERN;
1076     }
1077     usearch_reset(strsrch);
1078     if (U_FAILURE(status)) {
1079         log_err("Error setting pattern %s\n", u_errorName(status));
1080     }
1081     if (!assertEqualWithUStringSearch(strsrch, PATTERN[1])) {
1082         goto ENDTESTPATTERN;
1083     }
1084
1085     u_unescape(PATTERN[0].pattern, pattern, 32);
1086     usearch_setPattern(strsrch, pattern, -1, &status);
1087     temp = usearch_getPattern(strsrch, &templength);
1088     if (u_strcmp(pattern, temp) != 0) {
1089         log_err("Error setting pattern\n");
1090         goto ENDTESTPATTERN;
1091     }
1092     usearch_reset(strsrch);
1093     if (U_FAILURE(status)) {
1094         log_err("Error setting pattern %s\n", u_errorName(status));
1095     }
1096     if (!assertEqualWithUStringSearch(strsrch, PATTERN[0])) {
1097         goto ENDTESTPATTERN;
1098     }
1099     /* enormous pattern size to see if this crashes */
1100     for (templength = 0; templength != 512; templength ++) {
1101         bigpattern[templength] = 0x61;
1102     }
1103     bigpattern[511] = 0;
1104     usearch_setPattern(strsrch, bigpattern, -1, &status);
1105     if (U_FAILURE(status)) {
1106         log_err("Error setting pattern with size 512, %s \n",
1107             u_errorName(status));
1108     }
1109 ENDTESTPATTERN:
1110     ucol_setStrength(EN_US_, UCOL_TERTIARY);
1111     if (strsrch != NULL) {
1112         usearch_close(strsrch);
1113     }
1114     close();
1115 }
1116
1117 static void TestText(void)
1118 {
1119           UStringSearch *strsrch;
1120           UChar          pattern[32];
1121           UChar          text[128];
1122     const UChar         *temp;
1123           int32_t        templength;
1124           UErrorCode     status = U_ZERO_ERROR;
1125
1126     u_unescape(TEXT[0].text, text, 128);
1127     u_unescape(TEXT[0].pattern, pattern, 32);
1128
1129     open(&status);
1130     if (U_FAILURE(status)) {
1131         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1132         return;
1133     }
1134
1135     if (usearch_getText(NULL, &templength) != NULL) {
1136         log_err("Error NULL string search should return NULL text\n");
1137     }
1138
1139     usearch_setText(NULL, text, 10, &status);
1140     if (U_SUCCESS(status)) {
1141         log_err("Error NULL string search should have an error when setting text\n");
1142     }
1143
1144     status = U_ZERO_ERROR;
1145     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
1146                                        NULL, &status);
1147
1148     if (U_FAILURE(status)) {
1149         log_err("Error opening string search %s\n", u_errorName(status));
1150         goto ENDTESTPATTERN;
1151     }
1152     temp = usearch_getText(strsrch, &templength);
1153     if (u_strcmp(text, temp) != 0) {
1154         log_err("Error setting text\n");
1155     }
1156     if (!assertEqualWithUStringSearch(strsrch, TEXT[0])) {
1157         goto ENDTESTPATTERN;
1158     }
1159
1160     u_unescape(TEXT[1].text, text, 32);
1161     usearch_setText(strsrch, text, -1, &status);
1162     temp = usearch_getText(strsrch, &templength);
1163     if (u_strcmp(text, temp) != 0) {
1164         log_err("Error setting text\n");
1165         goto ENDTESTPATTERN;
1166     }
1167     if (U_FAILURE(status)) {
1168         log_err("Error setting text %s\n", u_errorName(status));
1169     }
1170     if (!assertEqualWithUStringSearch(strsrch, TEXT[1])) {
1171         goto ENDTESTPATTERN;
1172     }
1173
1174     u_unescape(TEXT[0].text, text, 32);
1175     usearch_setText(strsrch, text, -1, &status);
1176     temp = usearch_getText(strsrch, &templength);
1177     if (u_strcmp(text, temp) != 0) {
1178         log_err("Error setting text\n");
1179         goto ENDTESTPATTERN;
1180     }
1181     if (U_FAILURE(status)) {
1182         log_err("Error setting pattern %s\n", u_errorName(status));
1183     }
1184     if (!assertEqualWithUStringSearch(strsrch, TEXT[0])) {
1185         goto ENDTESTPATTERN;
1186     }
1187 ENDTESTPATTERN:
1188     if (strsrch != NULL) {
1189         usearch_close(strsrch);
1190     }
1191     close();
1192 }
1193
1194 static void TestCompositeBoundaries(void)
1195 {
1196     int count = 0;
1197     UErrorCode status = U_ZERO_ERROR;
1198     open(&status);
1199     if (U_FAILURE(status)) {
1200         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1201         return;
1202     }
1203     while (COMPOSITEBOUNDARIES[count].text != NULL) {
1204         log_verbose("composite %d\n", count);
1205         if (!assertEqual(COMPOSITEBOUNDARIES[count])) {
1206             log_err("Error at test number %d\n", count);
1207         }
1208         count ++;
1209     }
1210     close();
1211 }
1212
1213 static void TestGetSetOffset(void)
1214 {
1215     int            searchDataIndex   = 0;
1216     UChar          pattern[32];
1217     UChar          text[128];
1218     UErrorCode     status  = U_ZERO_ERROR;
1219     UStringSearch *strsrch;
1220     memset(pattern, 0, 32*sizeof(UChar));
1221     memset(text, 0, 128*sizeof(UChar));
1222
1223     open(&status);
1224     if (U_FAILURE(status)) {
1225         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1226         return;
1227     }
1228     if (usearch_getOffset(NULL) != USEARCH_DONE) {
1229         log_err("usearch_getOffset(NULL) expected USEARCH_DONE\n");
1230     }
1231     strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL,
1232                                        &status);
1233     /* testing out of bounds error */
1234     usearch_setOffset(strsrch, -1, &status);
1235     if (U_SUCCESS(status)) {
1236         log_err("Error expecting set offset error\n");
1237     }
1238     usearch_setOffset(strsrch, 128, &status);
1239     if (U_SUCCESS(status)) {
1240         log_err("Error expecting set offset error\n");
1241     }
1242     while (BASIC[searchDataIndex].text != NULL) {
1243         int         count       = 0;
1244         SearchData  search      = BASIC[searchDataIndex ++];
1245         int32_t matchindex  = search.offset[count];
1246         int32_t     textlength;
1247
1248         u_unescape(search.text, text, 128);
1249         u_unescape(search.pattern, pattern, 32);
1250         status = U_ZERO_ERROR;
1251         usearch_setText(strsrch, text, -1, &status);
1252         usearch_setPattern(strsrch, pattern, -1, &status);
1253         ucol_setStrength(usearch_getCollator(strsrch), search.strength);
1254         usearch_reset(strsrch);
1255         while (U_SUCCESS(status) && matchindex >= 0) {
1256             uint32_t matchlength = search.size[count];
1257             usearch_next(strsrch, &status);
1258             if (matchindex != usearch_getMatchedStart(strsrch) ||
1259                 matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
1260                 char *str = toCharString(usearch_getText(strsrch,
1261                                                          &textlength));
1262                 log_err("Text: %s\n", str);
1263                 str = toCharString(usearch_getPattern(strsrch, &textlength));
1264                 log_err("Pattern: %s\n", str);
1265                 log_err("Error match found at %d %d\n",
1266                         usearch_getMatchedStart(strsrch),
1267                         usearch_getMatchedLength(strsrch));
1268                 return;
1269             }
1270             usearch_setOffset(strsrch, matchindex + matchlength, &status);
1271             usearch_previous(strsrch, &status);
1272             if (matchindex != usearch_getMatchedStart(strsrch) ||
1273                 matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
1274                 char *str = toCharString(usearch_getText(strsrch,
1275                                                          &textlength));
1276                 log_err("Text: %s\n", str);
1277                 str = toCharString(usearch_getPattern(strsrch, &textlength));
1278                 log_err("Pattern: %s\n", str);
1279                 log_err("Error match found at %d %d\n",
1280                         usearch_getMatchedStart(strsrch),
1281                         usearch_getMatchedLength(strsrch));
1282                 return;
1283             }
1284             usearch_setOffset(strsrch, matchindex + matchlength, &status);
1285             matchindex = search.offset[count + 1] == -1 ? -1 :
1286                          search.offset[count + 2];
1287             if (search.offset[count + 1] != -1) {
1288                 usearch_setOffset(strsrch, search.offset[count + 1] + 1,
1289                                   &status);
1290                 if (usearch_getOffset(strsrch) != search.offset[count + 1] + 1) {
1291                     log_err("Error setting offset\n");
1292                     return;
1293                 }
1294             }
1295
1296             count += 2;
1297         }
1298         usearch_next(strsrch, &status);
1299         if (usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
1300             char *str = toCharString(usearch_getText(strsrch, &textlength));
1301             log_err("Text: %s\n", str);
1302             str = toCharString(usearch_getPattern(strsrch, &textlength));
1303             log_err("Pattern: %s\n", str);
1304             log_err("Error match found at %d %d\n",
1305                         usearch_getMatchedStart(strsrch),
1306                         usearch_getMatchedLength(strsrch));
1307             return;
1308         }
1309     }
1310     ucol_setStrength(usearch_getCollator(strsrch), UCOL_TERTIARY);
1311     usearch_close(strsrch);
1312     close();
1313 }
1314
1315 static void TestGetSetAttribute(void)
1316 {
1317     UErrorCode      status    = U_ZERO_ERROR;
1318     UChar           pattern[32];
1319     UChar           text[128];
1320     UStringSearch  *strsrch;
1321
1322     memset(pattern, 0, 32*sizeof(UChar));
1323     memset(text, 0, 128*sizeof(UChar));
1324
1325     open(&status);
1326     if (U_FAILURE(status)) {
1327         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1328         return;
1329     }
1330     if (usearch_getAttribute(NULL, USEARCH_OVERLAP) != USEARCH_DEFAULT ||
1331         usearch_getAttribute(NULL, USEARCH_CANONICAL_MATCH) !=
1332                                                          USEARCH_DEFAULT) {
1333         log_err(
1334             "Attributes for NULL string search should be USEARCH_DEFAULT\n");
1335     }
1336     strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL,
1337                                        &status);
1338     if (U_FAILURE(status)) {
1339         log_err("Error opening search %s\n", u_errorName(status));
1340         return;
1341     }
1342
1343     usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_DEFAULT, &status);
1344     if (U_FAILURE(status) ||
1345         usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
1346         log_err("Error setting overlap to the default\n");
1347     }
1348     usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
1349     if (U_FAILURE(status) ||
1350         usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
1351         log_err("Error setting overlap true\n");
1352     }
1353     usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
1354     if (U_FAILURE(status) ||
1355         usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
1356         log_err("Error setting overlap false\n");
1357     }
1358     usearch_setAttribute(strsrch, USEARCH_OVERLAP,
1359                          USEARCH_ATTRIBUTE_VALUE_COUNT, &status);
1360     if (U_SUCCESS(status)) {
1361         log_err("Error setting overlap to illegal value\n");
1362     }
1363     status = U_ZERO_ERROR;
1364     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_DEFAULT,
1365                          &status);
1366     if (U_FAILURE(status) ||
1367         usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) !=
1368                                                         USEARCH_OFF) {
1369         log_err("Error setting canonical match to the default\n");
1370     }
1371     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
1372                          &status);
1373     if (U_FAILURE(status) ||
1374         usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) !=
1375                                                          USEARCH_ON) {
1376         log_err("Error setting canonical match true\n");
1377     }
1378     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_OFF,
1379                          &status);
1380     if (U_FAILURE(status) ||
1381         usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) !=
1382                                                         USEARCH_OFF) {
1383         log_err("Error setting canonical match false\n");
1384     }
1385     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH,
1386                          USEARCH_ATTRIBUTE_VALUE_COUNT, &status);
1387     if (U_SUCCESS(status)) {
1388         log_err("Error setting canonical match to illegal value\n");
1389     }
1390     status = U_ZERO_ERROR;
1391     usearch_setAttribute(strsrch, USEARCH_ATTRIBUTE_COUNT, USEARCH_DEFAULT,
1392                          &status);
1393     if (U_SUCCESS(status)) {
1394         log_err("Error setting illegal attribute success\n");
1395     }
1396
1397     usearch_close(strsrch);
1398     close();
1399 }
1400
1401 static void TestGetMatch(void)
1402 {
1403     int            count       = 0;
1404     UErrorCode     status      = U_ZERO_ERROR;
1405     UChar          text[128];
1406     UChar          pattern[32];
1407     SearchData     search      = MATCH[0];
1408     int32_t    matchindex  = search.offset[count];
1409     UStringSearch *strsrch;
1410     int32_t        textlength;
1411     UChar          matchtext[128];
1412
1413     open(&status);
1414     if (U_FAILURE(status)) {
1415         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1416         return;
1417     }
1418
1419     if (usearch_getMatchedStart(NULL) != USEARCH_DONE ||
1420         usearch_getMatchedLength(NULL) != USEARCH_DONE) {
1421         log_err(
1422    "Expected start and length of NULL string search should be USEARCH_DONE\n");
1423     }
1424
1425     u_unescape(search.text, text, 128);
1426     u_unescape(search.pattern, pattern, 32);
1427     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
1428                                        NULL, &status);
1429     if (U_FAILURE(status)) {
1430         log_err("Error opening string search %s\n", u_errorName(status));
1431         if (strsrch != NULL) {
1432             usearch_close(strsrch);
1433         }
1434         return;
1435     }
1436
1437     while (U_SUCCESS(status) && matchindex >= 0) {
1438         int32_t matchlength = search.size[count];
1439         usearch_next(strsrch, &status);
1440         if (matchindex != usearch_getMatchedStart(strsrch) ||
1441             matchlength != usearch_getMatchedLength(strsrch)) {
1442             char *str = toCharString(usearch_getText(strsrch, &textlength));
1443             log_err("Text: %s\n", str);
1444             str = toCharString(usearch_getPattern(strsrch, &textlength));
1445             log_err("Pattern: %s\n", str);
1446             log_err("Error match found at %d %d\n",
1447                     usearch_getMatchedStart(strsrch),
1448                     usearch_getMatchedLength(strsrch));
1449             return;
1450         }
1451         count ++;
1452
1453         status = U_ZERO_ERROR;
1454         if (usearch_getMatchedText(NULL, matchtext, 128, &status) !=
1455             USEARCH_DONE || U_SUCCESS(status)){
1456             log_err("Error expecting errors with NULL string search\n");
1457         }
1458         status = U_ZERO_ERROR;
1459         if (usearch_getMatchedText(strsrch, NULL, 0, &status) !=
1460             (int32_t)matchlength || U_SUCCESS(status)){
1461             log_err("Error pre-flighting match length\n");
1462         }
1463         status = U_ZERO_ERROR;
1464         if (usearch_getMatchedText(strsrch, matchtext, 0, &status) !=
1465             (int32_t)matchlength || U_SUCCESS(status)){
1466             log_err("Error getting match text with buffer size 0\n");
1467         }
1468         status = U_ZERO_ERROR;
1469         if (usearch_getMatchedText(strsrch, matchtext, matchlength, &status)
1470             != (int32_t)matchlength || matchtext[matchlength - 1] == 0 ||
1471             U_FAILURE(status)){
1472             log_err("Error getting match text with exact size\n");
1473         }
1474         status = U_ZERO_ERROR;
1475         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
1476             (int32_t) matchlength || U_FAILURE(status) ||
1477             memcmp(matchtext,
1478                    usearch_getText(strsrch, &textlength) + matchindex,
1479                    matchlength * sizeof(UChar)) != 0 ||
1480             matchtext[matchlength] != 0) {
1481             log_err("Error getting matched text\n");
1482         }
1483
1484         matchindex = search.offset[count];
1485     }
1486     status = U_ZERO_ERROR;
1487     usearch_next(strsrch, &status);
1488     if (usearch_getMatchedStart(strsrch)  != USEARCH_DONE ||
1489         usearch_getMatchedLength(strsrch) != 0) {
1490         log_err("Error end of match not found\n");
1491     }
1492     status = U_ZERO_ERROR;
1493     if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
1494         USEARCH_DONE) {
1495         log_err("Error getting null matches\n");
1496     }
1497     usearch_close(strsrch);
1498     close();
1499 }
1500
1501 static void TestSetMatch(void)
1502 {
1503     int            count       = 0;
1504     UErrorCode status = U_ZERO_ERROR;
1505     open(&status);
1506     if (U_FAILURE(status)) {
1507         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1508         return;
1509     }
1510     while (MATCH[count].text != NULL) {
1511         SearchData     search = MATCH[count];
1512         int            size   = 0;
1513         int            offsetIndex = 0;
1514         UChar          text[128];
1515         UChar          pattern[32];
1516         UStringSearch *strsrch;
1517         status = U_ZERO_ERROR;
1518
1519         if (usearch_first(NULL, &status) != USEARCH_DONE ||
1520             usearch_last(NULL, &status) != USEARCH_DONE) {
1521             log_err("Error getting the first and last match of a NULL string search\n");
1522         }
1523         u_unescape(search.text, text, 128);
1524         u_unescape(search.pattern, pattern, 32);
1525         strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
1526                                            NULL, &status);
1527         if (U_FAILURE(status)) {
1528             log_err("Error opening string search %s\n", u_errorName(status));
1529             if (strsrch != NULL) {
1530                 usearch_close(strsrch);
1531             }
1532             return;
1533         }
1534
1535         size = 0;
1536         while (search.offset[size] != -1) {
1537             size ++;
1538         }
1539
1540         if (usearch_first(strsrch, &status) != search.offset[0] ||
1541             U_FAILURE(status)) {
1542             log_err("Error getting first match\n");
1543         }
1544         if (usearch_last(strsrch, &status) != search.offset[size -1] ||
1545             U_FAILURE(status)) {
1546             log_err("Error getting last match\n");
1547         }
1548
1549         while (offsetIndex < size) {
1550             if (offsetIndex + 2 < size) {
1551                 if (usearch_following(strsrch, search.offset[offsetIndex + 2] - 1,
1552                                       &status) != search.offset[offsetIndex + 2] ||
1553                     U_FAILURE(status)) {
1554                     log_err("Error getting following match at index %d\n",
1555                             search.offset[offsetIndex + 2] - 1);
1556                 }
1557             }
1558             if (offsetIndex + 1 < size) {
1559                 if (usearch_preceding(strsrch, search.offset[offsetIndex + 1] +
1560                                                search.size[offsetIndex + 1] + 1,
1561                                       &status) != search.offset[offsetIndex + 1] ||
1562                     U_FAILURE(status)) {
1563                     log_err("Error getting preceeding match at index %d\n",
1564                             search.offset[offsetIndex + 1] + 1);
1565                 }
1566             }
1567             offsetIndex += 2;
1568         }
1569         status = U_ZERO_ERROR;
1570         if (usearch_following(strsrch, u_strlen(text), &status) !=
1571             USEARCH_DONE) {
1572             log_err("Error expecting out of bounds match\n");
1573         }
1574         if (usearch_preceding(strsrch, 0, &status) != USEARCH_DONE) {
1575             log_err("Error expecting out of bounds match\n");
1576         }
1577         count ++;
1578         usearch_close(strsrch);
1579     }
1580     close();
1581 }
1582
1583 static void TestReset(void)
1584 {
1585     UErrorCode     status    = U_ZERO_ERROR;
1586     UChar          text[]    = {0x66, 0x69, 0x73, 0x68, 0x20,
1587                                 0x66, 0x69, 0x73, 0x68};
1588     UChar          pattern[] = {0x73};
1589     UStringSearch *strsrch;
1590
1591     open(&status);
1592     if (U_FAILURE(status)) {
1593         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1594         return;
1595     }
1596     strsrch = usearch_openFromCollator(pattern, 1, text, 9,
1597                                                       EN_US_, NULL, &status);
1598     if (U_FAILURE(status)) {
1599         log_err("Error opening string search %s\n", u_errorName(status));
1600         if (strsrch != NULL) {
1601             usearch_close(strsrch);
1602         }
1603         return;
1604     }
1605     usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
1606     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
1607                          &status);
1608     usearch_setOffset(strsrch, 9, &status);
1609     if (U_FAILURE(status)) {
1610         log_err("Error setting attributes and offsets\n");
1611     }
1612     else {
1613         usearch_reset(strsrch);
1614         if (usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF ||
1615             usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) !=
1616                                  USEARCH_OFF ||
1617             usearch_getOffset(strsrch) != 0 ||
1618             usearch_getMatchedLength(strsrch) != 0 ||
1619             usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
1620             log_err("Error resetting string search\n");
1621         }
1622         usearch_previous(strsrch, &status);
1623         if (usearch_getMatchedStart(strsrch) != 7 ||
1624             usearch_getMatchedLength(strsrch) != 1) {
1625             log_err("Error resetting string search\n");
1626         }
1627     }
1628     usearch_close(strsrch);
1629     close();
1630 }
1631
1632 static void TestSupplementary(void)
1633 {
1634     int count = 0;
1635     UErrorCode status = U_ZERO_ERROR;
1636     open(&status);
1637     if (U_FAILURE(status)) {
1638         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1639         return;
1640     }
1641     while (SUPPLEMENTARY[count].text != NULL) {
1642         if (!assertEqual(SUPPLEMENTARY[count])) {
1643             log_err("Error at test number %d\n", count);
1644         }
1645         count ++;
1646     }
1647     close();
1648 }
1649
1650 static void TestContraction(void)
1651 {
1652     UChar          rules[128];
1653     UChar          pattern[128];
1654     UChar          text[128];
1655     UCollator     *collator;
1656     UErrorCode     status = U_ZERO_ERROR;
1657     int            count = 0;
1658     UStringSearch *strsrch;
1659     memset(rules, 0, 128*sizeof(UChar));
1660     memset(pattern, 0, 128*sizeof(UChar));
1661     memset(text, 0, 128*sizeof(UChar));
1662
1663     u_unescape(CONTRACTIONRULE, rules, 128);
1664     collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON,
1665                               UCOL_TERTIARY, NULL, &status);
1666     if(status == U_FILE_ACCESS_ERROR) {
1667       log_data_err("Is your data around?\n");
1668       return;
1669     } else if(U_FAILURE(status)) {
1670       log_err("Error opening collator %s\n", u_errorName(status));
1671       return;
1672     }
1673     strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL,
1674                                        &status);
1675     if (U_FAILURE(status)) {
1676         log_err("Error opening string search %s\n", u_errorName(status));
1677     }
1678
1679     while (CONTRACTION[count].text != NULL) {
1680         u_unescape(CONTRACTION[count].text, text, 128);
1681         u_unescape(CONTRACTION[count].pattern, pattern, 128);
1682         usearch_setText(strsrch, text, -1, &status);
1683         usearch_setPattern(strsrch, pattern, -1, &status);
1684         if (!assertEqualWithUStringSearch(strsrch, CONTRACTION[count])) {
1685             log_err("Error at test number %d\n", count);
1686         }
1687         count ++;
1688     }
1689     usearch_close(strsrch);
1690     ucol_close(collator);
1691 }
1692
1693 static void TestIgnorable(void)
1694 {
1695     UChar          rules[128];
1696     UChar          pattern[128];
1697     UChar          text[128];
1698     UCollator     *collator;
1699     UErrorCode     status = U_ZERO_ERROR;
1700     UStringSearch *strsrch;
1701     uint32_t       count = 0;
1702
1703     memset(rules, 0, 128*sizeof(UChar));
1704     memset(pattern, 0, 128*sizeof(UChar));
1705     memset(text, 0, 128*sizeof(UChar));
1706
1707     u_unescape(IGNORABLERULE, rules, 128);
1708     collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON,
1709                               IGNORABLE[count].strength, NULL, &status);
1710     if(status == U_FILE_ACCESS_ERROR) {
1711       log_data_err("Is your data around?\n");
1712       return;
1713     } else if(U_FAILURE(status)) {
1714         log_err("Error opening collator %s\n", u_errorName(status));
1715         return;
1716     }
1717     strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL,
1718                                        &status);
1719     if (U_FAILURE(status)) {
1720         log_err("Error opening string search %s\n", u_errorName(status));
1721     }
1722
1723     while (IGNORABLE[count].text != NULL) {
1724         u_unescape(IGNORABLE[count].text, text, 128);
1725         u_unescape(IGNORABLE[count].pattern, pattern, 128);
1726         usearch_setText(strsrch, text, -1, &status);
1727         usearch_setPattern(strsrch, pattern, -1, &status);
1728         if (!assertEqualWithUStringSearch(strsrch, IGNORABLE[count])) {
1729             log_err("Error at test number %d\n", count);
1730         }
1731         count ++;
1732     }
1733     usearch_close(strsrch);
1734     ucol_close(collator);
1735 }
1736
1737 static void TestDiacriticMatch(void)
1738 {
1739     UChar          pattern[128];
1740     UChar          text[128];
1741     UErrorCode     status = U_ZERO_ERROR;
1742     UStringSearch *strsrch = NULL;
1743     UCollator *coll = NULL;
1744     uint32_t       count = 0;
1745     SearchData search;
1746
1747     memset(pattern, 0, 128*sizeof(UChar));
1748     memset(text, 0, 128*sizeof(UChar));
1749
1750     strsrch = usearch_open(pattern, 1, text, 1, uloc_getDefault(), NULL, &status);
1751     if (U_FAILURE(status)) {
1752         log_err_status(status, "Error opening string search %s\n", u_errorName(status));
1753         return;
1754     }
1755
1756     search = DIACRITICMATCH[count];
1757     while (search.text != NULL) {
1758         if (search.collator != NULL) {
1759             coll = ucol_openFromShortString(search.collator, FALSE, NULL, &status);
1760         } else {
1761             /* Always use "en_US" because some of these tests fail in Danish locales. */
1762             coll = ucol_open("en_US"/*uloc_getDefault()*/, &status);
1763             ucol_setStrength(coll, search.strength);
1764         }
1765         if (U_FAILURE(status)) {
1766             log_err("Error opening string search collator(\"%s\") %s\n", search.collator, u_errorName(status));
1767             return;
1768         }
1769
1770         usearch_setCollator(strsrch, coll, &status);
1771         if (U_FAILURE(status)) {
1772             log_err("Error setting string search collator %s\n", u_errorName(status));
1773             return;
1774         }
1775
1776         u_unescape(search.text, text, 128);
1777         u_unescape(search.pattern, pattern, 128);
1778         usearch_setText(strsrch, text, -1, &status);
1779         usearch_setPattern(strsrch, pattern, -1, &status);
1780         if (!assertEqualWithUStringSearch(strsrch, search)) {
1781             log_err("Error at test number %d\n", count);
1782         }
1783         ucol_close(coll);
1784
1785         search = DIACRITICMATCH[++count];
1786     }
1787     usearch_close(strsrch);
1788 }
1789
1790 static void TestCanonical(void)
1791 {
1792     int count = 0;
1793     UErrorCode status = U_ZERO_ERROR;
1794     open(&status);
1795     if (U_FAILURE(status)) {
1796         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1797         return;
1798     }
1799     while (BASICCANONICAL[count].text != NULL) {
1800         if (!assertCanonicalEqual(BASICCANONICAL[count])) {
1801             log_err("Error at test number %d\n", count);
1802         }
1803         count ++;
1804     }
1805     close();
1806 }
1807
1808 static void TestNormCanonical(void)
1809 {
1810     int count = 0;
1811     UErrorCode status = U_ZERO_ERROR;
1812     open(&status);
1813     if (U_FAILURE(status)) {
1814         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1815         return;
1816     }
1817     ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
1818     count = 0;
1819     while (NORMCANONICAL[count].text != NULL) {
1820         if (!assertCanonicalEqual(NORMCANONICAL[count])) {
1821             log_err("Error at test number %d\n", count);
1822         }
1823         count ++;
1824     }
1825     ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
1826     close();
1827 }
1828
1829 static void TestStrengthCanonical(void)
1830 {
1831     int count = 0;
1832     UErrorCode status = U_ZERO_ERROR;
1833     open(&status);
1834     if (U_FAILURE(status)) {
1835         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1836         return;
1837     }
1838     while (STRENGTHCANONICAL[count].text != NULL) {
1839         if (!assertCanonicalEqual(STRENGTHCANONICAL[count])) {
1840             log_err("Error at test number %d\n", count);
1841         }
1842         count ++;
1843     }
1844     close();
1845 }
1846
1847 static void TestBreakIteratorCanonical(void) {
1848     UErrorCode      status      = U_ZERO_ERROR;
1849     int             count = 0;
1850
1851     CHECK_BREAK("x");
1852
1853 #if !UCONFIG_NO_BREAK_ITERATION
1854
1855     open(&status);
1856     if (U_FAILURE(status)) {
1857         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1858         return;
1859     }
1860     while (count < 4) {
1861         /* 0-3 test are fixed */
1862               UChar           pattern[32];
1863               UChar           text[128];
1864         const SearchData     *search   = &(BREAKITERATORCANONICAL[count]);
1865               UCollator      *collator = getCollator(search->collator);
1866               UBreakIterator *breaker  = getBreakIterator(search->breaker);
1867               UStringSearch  *strsrch;
1868
1869         u_unescape(search->text, text, 128);
1870         u_unescape(search->pattern, pattern, 32);
1871         ucol_setStrength(collator, search->strength);
1872
1873         strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
1874                                            breaker, &status);
1875         if(status == U_FILE_ACCESS_ERROR) {
1876             log_data_err("Is your data around?\n");
1877             goto ENDTESTBREAKITERATOR;
1878         } else if(U_FAILURE(status)) {
1879             log_err("Error opening searcher\n");
1880             goto ENDTESTBREAKITERATOR;
1881         }
1882         usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
1883                              &status);
1884         if (U_FAILURE(status) ||
1885             usearch_getBreakIterator(strsrch) != breaker) {
1886             log_err("Error setting break iterator\n");
1887             usearch_close(strsrch);
1888             goto ENDTESTBREAKITERATOR;
1889         }
1890         if (!assertEqualWithUStringSearch(strsrch, *search)) {
1891             ucol_setStrength(collator, UCOL_TERTIARY);
1892             usearch_close(strsrch);
1893             goto ENDTESTBREAKITERATOR;
1894         }
1895         search   = &(BREAKITERATOREXACT[count + 1]);
1896         breaker  = getBreakIterator(search->breaker);
1897         usearch_setBreakIterator(strsrch, breaker, &status);
1898         if (U_FAILURE(status) || usearch_getBreakIterator(strsrch) != breaker) {
1899             log_err("Error setting break iterator\n");
1900             usearch_close(strsrch);
1901             goto ENDTESTBREAKITERATOR;
1902         }
1903         usearch_reset(strsrch);
1904         usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
1905                              &status);
1906         if (!assertEqualWithUStringSearch(strsrch, *search)) {
1907             log_err("Error at test number %d\n", count);
1908             usearch_close(strsrch);
1909             goto ENDTESTBREAKITERATOR;
1910         }
1911         usearch_close(strsrch);
1912         count += 2;
1913     }
1914     count = 0;
1915     while (BREAKITERATORCANONICAL[count].text != NULL) {
1916          if (!assertEqual(BREAKITERATORCANONICAL[count])) {
1917              log_err("Error at test number %d\n", count);
1918              goto ENDTESTBREAKITERATOR;
1919          }
1920          count ++;
1921     }
1922
1923 ENDTESTBREAKITERATOR:
1924     close();
1925 #endif
1926 }
1927
1928 static void TestVariableCanonical(void)
1929 {
1930     int count = 0;
1931     UErrorCode status = U_ZERO_ERROR;
1932     open(&status);
1933     if (U_FAILURE(status)) {
1934         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1935         return;
1936     }
1937     ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
1938     if (U_FAILURE(status)) {
1939         log_err("Error setting collation alternate attribute %s\n",
1940             u_errorName(status));
1941     }
1942     while (VARIABLE[count].text != NULL) {
1943         log_verbose("variable %d\n", count);
1944         if (!assertCanonicalEqual(VARIABLE[count])) {
1945             log_err("Error at test number %d\n", count);
1946         }
1947         count ++;
1948     }
1949     ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING,
1950                       UCOL_NON_IGNORABLE, &status);
1951     close();
1952 }
1953
1954 static void TestOverlapCanonical(void)
1955 {
1956     int count = 0;
1957     UErrorCode status = U_ZERO_ERROR;
1958     open(&status);
1959     if (U_FAILURE(status)) {
1960         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
1961         return;
1962     }
1963     while (OVERLAPCANONICAL[count].text != NULL) {
1964         if (!assertEqualWithAttribute(OVERLAPCANONICAL[count], USEARCH_ON,
1965                                       USEARCH_ON)) {
1966             log_err("Error at overlap test number %d\n", count);
1967         }
1968         count ++;
1969     }
1970     count = 0;
1971     while (NONOVERLAP[count].text != NULL) {
1972         if (!assertCanonicalEqual(NONOVERLAPCANONICAL[count])) {
1973             log_err("Error at non overlap test number %d\n", count);
1974         }
1975         count ++;
1976     }
1977
1978     count = 0;
1979     while (count < 1) {
1980               UChar           pattern[32];
1981               UChar           text[128];
1982         const SearchData     *search   = &(OVERLAPCANONICAL[count]);
1983               UCollator      *collator = getCollator(search->collator);
1984               UStringSearch  *strsrch;
1985               status   = U_ZERO_ERROR;
1986
1987         u_unescape(search->text, text, 128);
1988         u_unescape(search->pattern, pattern, 32);
1989         strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator,
1990                                            NULL, &status);
1991         if(status == U_FILE_ACCESS_ERROR) {
1992           log_data_err("Is your data around?\n");
1993           return;
1994         } else if(U_FAILURE(status)) {
1995           log_err("Error opening searcher\n");
1996           return;
1997         }
1998         usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
1999                              &status);
2000         usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
2001         if (U_FAILURE(status) ||
2002             usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
2003             log_err("Error setting overlap option\n");
2004         }
2005         if (!assertEqualWithUStringSearch(strsrch, *search)) {
2006             usearch_close(strsrch);
2007             return;
2008         }
2009         search   = &(NONOVERLAPCANONICAL[count]);
2010         usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
2011         if (U_FAILURE(status) ||
2012             usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
2013             log_err("Error setting overlap option\n");
2014         }
2015         usearch_reset(strsrch);
2016         if (!assertEqualWithUStringSearch(strsrch, *search)) {
2017             usearch_close(strsrch);
2018             log_err("Error at test number %d\n", count);
2019          }
2020
2021         count ++;
2022         usearch_close(strsrch);
2023     }
2024     close();
2025 }
2026
2027 static void TestCollatorCanonical(void)
2028 {
2029     /* test collator that thinks "o" and "p" are the same thing */
2030           UChar          rules[32];
2031           UCollator     *tailored = NULL;
2032           UErrorCode     status = U_ZERO_ERROR;
2033           UChar          pattern[32];
2034           UChar          text[128];
2035           UStringSearch *strsrch;
2036
2037     open(&status);
2038     if (U_FAILURE(status)) {
2039         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2040         return;
2041     }
2042     u_unescape(COLLATORCANONICAL[0].text, text, 128);
2043     u_unescape(COLLATORCANONICAL[0].pattern, pattern, 32);
2044
2045     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
2046                                        NULL, &status);
2047     if(status == U_FILE_ACCESS_ERROR) {
2048       log_data_err("Is your data around?\n");
2049       return;
2050     } else if(U_FAILURE(status)) {
2051       log_err("Error opening searcher\n");
2052       return;
2053     }
2054     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2055                          &status);
2056     if (U_FAILURE(status)) {
2057         log_err("Error opening string search %s\n", u_errorName(status));
2058     }
2059     if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[0])) {
2060         goto ENDTESTCOLLATOR;
2061     }
2062
2063     u_unescape(TESTCOLLATORRULE, rules, 32);
2064     tailored = ucol_openRules(rules, -1, UCOL_ON,
2065                               COLLATORCANONICAL[1].strength, NULL, &status);
2066     if (U_FAILURE(status)) {
2067         log_err("Error opening rule based collator %s\n", u_errorName(status));
2068     }
2069
2070     usearch_setCollator(strsrch, tailored, &status);
2071     if (U_FAILURE(status) || usearch_getCollator(strsrch) != tailored) {
2072         log_err("Error setting rule based collator\n");
2073     }
2074     usearch_reset(strsrch);
2075     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2076                          &status);
2077     if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[1])) {
2078         goto ENDTESTCOLLATOR;
2079     }
2080
2081     usearch_setCollator(strsrch, EN_US_, &status);
2082     usearch_reset(strsrch);
2083     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2084                          &status);
2085     if (U_FAILURE(status) || usearch_getCollator(strsrch) != EN_US_) {
2086         log_err("Error setting rule based collator\n");
2087     }
2088     if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[0])) {
2089         goto ENDTESTCOLLATOR;
2090     }
2091
2092 ENDTESTCOLLATOR:
2093     usearch_close(strsrch);
2094     if (tailored != NULL) {
2095         ucol_close(tailored);
2096     }
2097     close();
2098 }
2099
2100 static void TestPatternCanonical(void)
2101 {
2102           UStringSearch *strsrch;
2103           UChar          pattern[32];
2104           UChar          text[128];
2105     const UChar         *temp;
2106           int32_t        templength;
2107           UErrorCode     status = U_ZERO_ERROR;
2108
2109     open(&status);
2110     if (U_FAILURE(status)) {
2111         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2112         return;
2113     }
2114     u_unescape(PATTERNCANONICAL[0].text, text, 128);
2115     u_unescape(PATTERNCANONICAL[0].pattern, pattern, 32);
2116
2117     ucol_setStrength(EN_US_, PATTERNCANONICAL[0].strength);
2118     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
2119                                        NULL, &status);
2120     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2121                          &status);
2122     if (U_FAILURE(status)) {
2123         log_err("Error opening string search %s\n", u_errorName(status));
2124         goto ENDTESTPATTERN;
2125     }
2126     temp = usearch_getPattern(strsrch, &templength);
2127     if (u_strcmp(pattern, temp) != 0) {
2128         log_err("Error setting pattern\n");
2129     }
2130     if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[0])) {
2131         goto ENDTESTPATTERN;
2132     }
2133
2134     u_unescape(PATTERNCANONICAL[1].pattern, pattern, 32);
2135     usearch_setPattern(strsrch, pattern, -1, &status);
2136     temp = usearch_getPattern(strsrch, &templength);
2137     if (u_strcmp(pattern, temp) != 0) {
2138         log_err("Error setting pattern\n");
2139         goto ENDTESTPATTERN;
2140     }
2141     usearch_reset(strsrch);
2142     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2143                          &status);
2144     if (U_FAILURE(status)) {
2145         log_err("Error setting pattern %s\n", u_errorName(status));
2146     }
2147     if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[1])) {
2148         goto ENDTESTPATTERN;
2149     }
2150
2151     u_unescape(PATTERNCANONICAL[0].pattern, pattern, 32);
2152     usearch_setPattern(strsrch, pattern, -1, &status);
2153     temp = usearch_getPattern(strsrch, &templength);
2154     if (u_strcmp(pattern, temp) != 0) {
2155         log_err("Error setting pattern\n");
2156         goto ENDTESTPATTERN;
2157     }
2158     usearch_reset(strsrch);
2159     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2160                          &status);
2161     if (U_FAILURE(status)) {
2162         log_err("Error setting pattern %s\n", u_errorName(status));
2163     }
2164     if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[0])) {
2165         goto ENDTESTPATTERN;
2166     }
2167 ENDTESTPATTERN:
2168     ucol_setStrength(EN_US_, UCOL_TERTIARY);
2169     if (strsrch != NULL) {
2170         usearch_close(strsrch);
2171     }
2172     close();
2173 }
2174
2175 static void TestTextCanonical(void)
2176 {
2177           UStringSearch *strsrch;
2178           UChar          pattern[32];
2179           UChar          text[128];
2180     const UChar         *temp;
2181           int32_t        templength;
2182           UErrorCode     status = U_ZERO_ERROR;
2183
2184     u_unescape(TEXTCANONICAL[0].text, text, 128);
2185     u_unescape(TEXTCANONICAL[0].pattern, pattern, 32);
2186
2187     open(&status);
2188     if (U_FAILURE(status)) {
2189         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2190         return;
2191     }
2192     strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_,
2193                                        NULL, &status);
2194     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2195                          &status);
2196
2197     if (U_FAILURE(status)) {
2198         log_err("Error opening string search %s\n", u_errorName(status));
2199         goto ENDTESTPATTERN;
2200     }
2201     temp = usearch_getText(strsrch, &templength);
2202     if (u_strcmp(text, temp) != 0) {
2203         log_err("Error setting text\n");
2204     }
2205     if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[0])) {
2206         goto ENDTESTPATTERN;
2207     }
2208
2209     u_unescape(TEXTCANONICAL[1].text, text, 32);
2210     usearch_setText(strsrch, text, -1, &status);
2211     temp = usearch_getText(strsrch, &templength);
2212     if (u_strcmp(text, temp) != 0) {
2213         log_err("Error setting text\n");
2214         goto ENDTESTPATTERN;
2215     }
2216     if (U_FAILURE(status)) {
2217         log_err("Error setting text %s\n", u_errorName(status));
2218     }
2219     if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[1])) {
2220         goto ENDTESTPATTERN;
2221     }
2222
2223     u_unescape(TEXTCANONICAL[0].text, text, 32);
2224     usearch_setText(strsrch, text, -1, &status);
2225     temp = usearch_getText(strsrch, &templength);
2226     if (u_strcmp(text, temp) != 0) {
2227         log_err("Error setting text\n");
2228         goto ENDTESTPATTERN;
2229     }
2230     if (U_FAILURE(status)) {
2231         log_err("Error setting pattern %s\n", u_errorName(status));
2232     }
2233     if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[0])) {
2234         goto ENDTESTPATTERN;
2235     }
2236 ENDTESTPATTERN:
2237     if (strsrch != NULL) {
2238         usearch_close(strsrch);
2239     }
2240     close();
2241 }
2242
2243 static void TestCompositeBoundariesCanonical(void)
2244 {
2245     int count = 0;
2246     UErrorCode status = U_ZERO_ERROR;
2247     open(&status);
2248     if (U_FAILURE(status)) {
2249         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2250         return;
2251     }
2252     while (COMPOSITEBOUNDARIESCANONICAL[count].text != NULL) {
2253         log_verbose("composite %d\n", count);
2254         if (!assertCanonicalEqual(COMPOSITEBOUNDARIESCANONICAL[count])) {
2255             log_err("Error at test number %d\n", count);
2256         }
2257         count ++;
2258     }
2259     close();
2260 }
2261
2262 static void TestGetSetOffsetCanonical(void)
2263 {
2264     int            searchDataIndex   = 0;
2265     UChar          pattern[32];
2266     UChar          text[128];
2267     UErrorCode     status  = U_ZERO_ERROR;
2268     UStringSearch *strsrch;
2269     UCollator     *collator;
2270
2271     memset(pattern, 0, 32*sizeof(UChar));
2272     memset(text, 0, 128*sizeof(UChar));
2273
2274     open(&status);
2275     if (U_FAILURE(status)) {
2276         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2277         return;
2278     }
2279     strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL,
2280                                        &status);
2281
2282     collator = usearch_getCollator(strsrch);
2283     ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
2284
2285     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2286                          &status);
2287
2288     /* testing out of bounds error */
2289     usearch_setOffset(strsrch, -1, &status);
2290     if (U_SUCCESS(status)) {
2291         log_err("Error expecting set offset error\n");
2292     }
2293     usearch_setOffset(strsrch, 128, &status);
2294     if (U_SUCCESS(status)) {
2295         log_err("Error expecting set offset error\n");
2296     }
2297     while (BASICCANONICAL[searchDataIndex].text != NULL) {
2298         int         count       = 0;
2299         SearchData  search      = BASICCANONICAL[searchDataIndex ++];
2300         int32_t matchindex  = search.offset[count];
2301         int32_t     textlength;
2302
2303         if (BASICCANONICAL[searchDataIndex].text == NULL) {
2304             /* skip the last one */
2305             break;
2306         }
2307
2308         u_unescape(search.text, text, 128);
2309         u_unescape(search.pattern, pattern, 32);
2310         status = U_ZERO_ERROR;
2311         usearch_setText(strsrch, text, -1, &status);
2312         usearch_setPattern(strsrch, pattern, -1, &status);
2313         while (U_SUCCESS(status) && matchindex >= 0) {
2314             uint32_t matchlength = search.size[count];
2315             usearch_next(strsrch, &status);
2316             if (matchindex != usearch_getMatchedStart(strsrch) ||
2317                 matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
2318                 char *str = toCharString(usearch_getText(strsrch,
2319                                                          &textlength));
2320                 log_err("Text: %s\n", str);
2321                 str = toCharString(usearch_getPattern(strsrch, &textlength));
2322                 log_err("Pattern: %s\n", str);
2323                 log_err("Error match found at %d %d\n",
2324                         usearch_getMatchedStart(strsrch),
2325                         usearch_getMatchedLength(strsrch));
2326                 goto bail;
2327             }
2328             matchindex = search.offset[count + 1] == -1 ? -1 :
2329                          search.offset[count + 2];
2330             if (search.offset[count + 1] != -1) {
2331                 usearch_setOffset(strsrch, search.offset[count + 1] + 1,
2332                                   &status);
2333                 if (usearch_getOffset(strsrch) != search.offset[count + 1] + 1) {
2334                     log_err("Error setting offset\n");
2335                     goto bail;
2336                 }
2337             }
2338
2339             count += 2;
2340         }
2341         usearch_next(strsrch, &status);
2342         if (usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
2343             char *str = toCharString(usearch_getText(strsrch, &textlength));
2344             log_err("Text: %s\n", str);
2345             str = toCharString(usearch_getPattern(strsrch, &textlength));
2346             log_err("Pattern: %s\n", str);
2347             log_err("Error match found at %d %d\n",
2348                         usearch_getMatchedStart(strsrch),
2349                         usearch_getMatchedLength(strsrch));
2350             goto bail;
2351         }
2352     }
2353
2354 bail:
2355     ucol_setAttribute(collator, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
2356     usearch_close(strsrch);
2357     close();
2358 }
2359
2360 static void TestSupplementaryCanonical(void)
2361 {
2362     int count = 0;
2363     UErrorCode status = U_ZERO_ERROR;
2364     open(&status);
2365     if (U_FAILURE(status)) {
2366         log_err_status(status, "Unable to open static collators %s\n", u_errorName(status));
2367         return;
2368     }
2369     while (SUPPLEMENTARYCANONICAL[count].text != NULL) {
2370         if (!assertCanonicalEqual(SUPPLEMENTARYCANONICAL[count])) {
2371             log_err("Error at test number %d\n", count);
2372         }
2373         count ++;
2374     }
2375     close();
2376 }
2377
2378 static void TestContractionCanonical(void)
2379 {
2380     UChar          rules[128];
2381     UChar          pattern[128];
2382     UChar          text[128];
2383     UCollator     *collator = NULL;
2384     UErrorCode     status = U_ZERO_ERROR;
2385     int            count = 0;
2386     UStringSearch *strsrch = NULL;
2387     memset(rules, 0, 128*sizeof(UChar));
2388     memset(pattern, 0, 128*sizeof(UChar));
2389     memset(text, 0, 128*sizeof(UChar));
2390
2391     u_unescape(CONTRACTIONRULE, rules, 128);
2392     collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON,
2393                               UCOL_TERTIARY, NULL, &status);
2394     if(status == U_FILE_ACCESS_ERROR) {
2395       log_data_err("Is your data around?\n");
2396       return;
2397     } else if(U_FAILURE(status)) {
2398       log_err("Error opening collator %s\n", u_errorName(status));
2399       return;
2400     }
2401     strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL,
2402                                        &status);
2403     usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
2404                          &status);
2405     if (U_FAILURE(status)) {
2406         log_err("Error opening string search %s\n", u_errorName(status));
2407     }
2408
2409     while (CONTRACTIONCANONICAL[count].text != NULL) {
2410         u_unescape(CONTRACTIONCANONICAL[count].text, text, 128);
2411         u_unescape(CONTRACTIONCANONICAL[count].pattern, pattern, 128);
2412         usearch_setText(strsrch, text, -1, &status);
2413         usearch_setPattern(strsrch, pattern, -1, &status);
2414         if (!assertEqualWithUStringSearch(strsrch,
2415                                               CONTRACTIONCANONICAL[count])) {
2416             log_err("Error at test number %d\n", count);
2417         }
2418         count ++;
2419     }
2420     usearch_close(strsrch);
2421     ucol_close(collator);
2422 }
2423
2424 static void TestNumeric(void) {
2425     UCollator     *coll = NULL;
2426     UStringSearch *strsrch = NULL;
2427     UErrorCode     status = U_ZERO_ERROR;
2428
2429     UChar          pattern[128];
2430     UChar          text[128];
2431     memset(pattern, 0, 128*sizeof(UChar));
2432     memset(text, 0, 128*sizeof(UChar));
2433
2434     coll = ucol_open("", &status);
2435     if(U_FAILURE(status)) {
2436         log_data_err("Could not open UCA. Is your data around?\n");
2437         return;
2438     }
2439
2440     ucol_setAttribute(coll, UCOL_NUMERIC_COLLATION, UCOL_ON, &status);
2441
2442     strsrch = usearch_openFromCollator(pattern, 1, text, 1, coll, NULL, &status);
2443
2444     if(status != U_UNSUPPORTED_ERROR || U_SUCCESS(status)) {
2445         log_err("Expected U_UNSUPPORTED_ERROR when trying to instantiate a search object from a CODAN collator, got %s instead\n", u_errorName(status));
2446         if(strsrch) {
2447             usearch_close(strsrch);
2448         }
2449     }
2450
2451     ucol_close(coll);
2452
2453 }
2454
2455 /* This test is for ticket 4038 due to incorrect backward searching when certain patterns have a length > 1 */
2456 static void TestForwardBackward(void) {
2457     UErrorCode status = U_ZERO_ERROR;
2458     UCollator *coll = NULL;
2459     UStringSearch *search = NULL;
2460     UChar usrcstr[32], value[4];
2461     int32_t pos= -1;
2462     int32_t expectedPos = 9;
2463
2464     coll = ucol_open("en_GB", &status);
2465     if (U_FAILURE(status)) {
2466         log_err_status(status, "ucol_open failed: %s\n", u_errorName(status));
2467         goto exitTestForwardBackward;
2468     }
2469     ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_PRIMARY, &status);
2470     ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_ON, &status);
2471     ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
2472
2473     u_uastrcpy(usrcstr, "QBitArray::bitarr_data"); /* text */
2474     u_uastrcpy(value, "::");                       /* pattern */
2475
2476     search = usearch_openFromCollator(value, 2, usrcstr, 22, coll, NULL, &status);
2477     if (U_FAILURE(status)) {
2478         log_err("usearch_openFromCollator failed: %s\n", u_errorName(status));
2479         goto exitTestForwardBackward;
2480     }
2481
2482     usearch_reset(search);
2483     /* forward search */
2484     pos = usearch_first(search, &status);
2485     if (pos != expectedPos) {
2486         log_err("Expected search result: %d; Got instead: %d\n", expectedPos, pos);
2487         goto exitTestForwardBackward;
2488     }
2489
2490     pos = -1;
2491     usearch_reset(search);
2492     /* backward search */
2493     pos = usearch_last(search, &status);
2494     if (pos != expectedPos) {
2495         log_err("Expected search result: %d; Got instead: %d\n", expectedPos, pos);
2496     }
2497
2498 exitTestForwardBackward :
2499     if (coll != NULL) {
2500         ucol_close(coll);
2501     }
2502     if (search != NULL) {
2503         usearch_close(search);
2504     }
2505 }
2506
2507 #define TEST_ASSERT(x) \
2508    {if (U_FAILURE(x)) {log_err_status(x, "%s:%d: FAIL: test assertion failure \n", __FILE__, __LINE__);\
2509    }}
2510
2511 static void TestSearchForNull(void) {
2512     UCollator *coll;
2513     UErrorCode ec;
2514     UStringSearch *search;
2515     int pos;
2516     int len;
2517     int expectedPos;
2518     int expectedLen;
2519     int expectedNum;
2520     int count = 0;
2521     const UChar zerodigit = 0x0030; /* 0 */
2522     const UChar nulldigit = 0x0000; /* null */
2523
2524     /* static const UChar var[(length)+1]=U_DECLARE_UTF16(cs) */
2525 #define PATTERN_LEN 4
2526 #define TEXT_LEN 10
2527
2528     U_STRING_DECL(_pattern, "IS 0", PATTERN_LEN);
2529     U_STRING_DECL(_text, "_0IS 0 OK?", TEXT_LEN);
2530     UChar pattern[PATTERN_LEN + 1], text[TEXT_LEN + 1];
2531
2532     U_STRING_INIT(_pattern, "IS 0", PATTERN_LEN);
2533     U_STRING_INIT(_text, "_0IS 0 OK?", TEXT_LEN);
2534     expectedPos = 2;
2535     expectedLen = 4;
2536     expectedNum = 1;
2537
2538     for (pos = 0; pos < PATTERN_LEN; pos++) {
2539         if (_pattern[pos] == zerodigit) {
2540             pattern[pos] = nulldigit;
2541         } else {
2542             pattern[pos] = _pattern[pos];
2543         }
2544     }
2545     pattern[PATTERN_LEN] = 0x0000;
2546
2547     for (pos = 0; pos < TEXT_LEN; pos++) {
2548         if (_text[pos] == zerodigit) {
2549             text[pos] = nulldigit;
2550         } else {
2551             text[pos] = _text[pos];
2552         }
2553     }
2554     text[TEXT_LEN] = 0x0000;
2555
2556     ec = U_ZERO_ERROR;
2557
2558     /* create a US-English collator */
2559     coll = ucol_open("en_US", &ec);
2560
2561     /* make sure we didn't fail. */
2562      TEST_ASSERT (ec);
2563
2564     ucol_setStrength(coll, UCOL_IDENTICAL);
2565
2566     /* open a search looking for 0 */
2567     search = usearch_openFromCollator(pattern, PATTERN_LEN, text,
2568             TEXT_LEN, coll, NULL, &ec);
2569      TEST_ASSERT (ec);
2570
2571     if (coll != NULL && search != NULL) {
2572         pos = usearch_first(search, &ec);
2573         len = usearch_getMatchedLength(search);
2574         if (pos != expectedPos) {
2575             log_err("Expected search result: %d; Got instead: %d\n", expectedPos,
2576                     pos);
2577         }
2578
2579         if (len != expectedLen) {
2580             log_err("Expected search result length: %d; Got instead: %d\n",
2581                     expectedLen, len);
2582         }
2583
2584         for (pos = usearch_first(search, &ec); pos != USEARCH_DONE; pos
2585                 = usearch_next(search, &ec)) {
2586             log_verbose("Match at %d\n", pos);
2587             count += 1;
2588         }
2589
2590         if (count != expectedNum) {
2591             log_err("Expected %d search hits, found %d\n", expectedNum, count);
2592         }
2593     }
2594
2595     ucol_close(coll);
2596     usearch_close(search);
2597 }
2598
2599 static void TestStrengthIdentical(void)
2600 {
2601     UCollator *coll;
2602     UErrorCode ec = U_ZERO_ERROR;
2603     UStringSearch *search;
2604
2605     UChar pattern[] = {0x05E9, 0x0591, 0x05E9};
2606     UChar text[]    = {0x05E9, 0x0592, 0x05E9};
2607     int32_t pLen = sizeof (pattern) / sizeof(pattern[0]);
2608     int32_t tLen = sizeof(text) / sizeof (text[0]);
2609     int32_t expectedPos = 0;
2610     int32_t expectedLen = 3;
2611
2612     int32_t pos;
2613     int32_t len;
2614
2615     /* create a US-English collator */
2616     coll = ucol_open ("en_US", &ec);
2617
2618     /* make sure we didn't fail. */
2619     TEST_ASSERT (ec);
2620
2621     ucol_setStrength( coll, UCOL_TERTIARY);
2622
2623     /* open a search looking for 0 */
2624     search = usearch_openFromCollator (pattern, pLen, text, tLen, coll, NULL, &ec);
2625     TEST_ASSERT (ec);
2626
2627     if (coll != NULL && search != NULL) {
2628         pos = usearch_first(search, &ec);
2629         len = usearch_getMatchedLength(search);
2630
2631         if(pos != expectedPos) {
2632             log_err("Expected search result: %d; Got instead: %d\n", expectedPos, pos);
2633         }
2634
2635         if(len != expectedLen) {
2636             log_err("Expected search result length: %d; Got instead: %d\n", expectedLen, len);
2637         }
2638
2639         /* Now try it at strength == UCOL_IDENTICAL */
2640         ucol_setStrength(coll, UCOL_IDENTICAL);
2641         usearch_reset(search);
2642
2643         pos = usearch_first(search, &ec);
2644         len = usearch_getMatchedLength(search);
2645
2646         if(pos != -1) {
2647             log_err("Expected failure for strentgh = UCOL_IDENTICAL: got %d instead.\n", pos);
2648         }
2649     }
2650
2651     usearch_close(search);
2652     ucol_close(coll);
2653 }
2654
2655 /**
2656 * TestUsingSearchCollator
2657 */
2658
2659 #define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
2660
2661 typedef struct {
2662     const UChar *   pattern;
2663     const int32_t * offsets;
2664     int32_t         offsetsLen;
2665 } PatternAndOffsets;
2666
2667 static const UChar scKoText[] = {
2668        0x0020,
2669 /*01*/ 0xAC00, 0x0020,                         /* simple LV Hangul */
2670 /*03*/ 0xAC01, 0x0020,                         /* simple LVT Hangul */
2671 /*05*/ 0xAC0F, 0x0020,                         /* LVTT, last jamo expands for search */
2672 /*07*/ 0xAFFF, 0x0020,                         /* LLVVVTT, every jamo expands for search */
2673 /*09*/ 0x1100, 0x1161, 0x11A8, 0x0020,         /* 0xAC01 as conjoining jamo */
2674 /*13*/ 0x1100, 0x1161, 0x1100, 0x0020,         /* 0xAC01 as basic conjoining jamo (per search rules) */
2675 /*17*/ 0x3131, 0x314F, 0x3131, 0x0020,         /* 0xAC01 as compatibility jamo */
2676 /*21*/ 0x1100, 0x1161, 0x11B6, 0x0020,         /* 0xAC0F as conjoining jamo; last expands for search */
2677 /*25*/ 0x1100, 0x1161, 0x1105, 0x1112, 0x0020, /* 0xAC0F as basic conjoining jamo; last expands for search */
2678 /*30*/ 0x1101, 0x1170, 0x11B6, 0x0020,         /* 0xAFFF as conjoining jamo; all expand for search */
2679 /*34*/ 0x00E6, 0x0020,                         /* small letter ae, expands */
2680 /*36*/ 0x1E4D, 0x0020,                         /* small letter o with tilde and acute, decomposes */
2681        0
2682 };
2683
2684 static const UChar scKoPat0[] = { 0xAC01, 0 };
2685 static const UChar scKoPat1[] = { 0x1100, 0x1161, 0x11A8, 0 }; /* 0xAC01 as conjoining jamo */
2686 static const UChar scKoPat2[] = { 0xAC0F, 0 };
2687 static const UChar scKoPat3[] = { 0x1100, 0x1161, 0x1105, 0x1112, 0 }; /* 0xAC0F as basic conjoining jamo */
2688 static const UChar scKoPat4[] = { 0xAFFF, 0 };
2689 static const UChar scKoPat5[] = { 0x1101, 0x1170, 0x11B6, 0 }; /* 0xAFFF as conjoining jamo */
2690
2691 static const int32_t scKoSrchOff01[] = { 3,  9, 13 };
2692 static const int32_t scKoSrchOff23[] = { 5, 21, 25 };
2693 static const int32_t scKoSrchOff45[] = { 7, 30     };
2694
2695 static const PatternAndOffsets scKoSrchPatternsOffsets[] = {
2696     { scKoPat0, scKoSrchOff01, ARRAY_LENGTH(scKoSrchOff01) },
2697     { scKoPat1, scKoSrchOff01, ARRAY_LENGTH(scKoSrchOff01) },
2698     { scKoPat2, scKoSrchOff23, ARRAY_LENGTH(scKoSrchOff23) },
2699     { scKoPat3, scKoSrchOff23, ARRAY_LENGTH(scKoSrchOff23) },
2700     { scKoPat4, scKoSrchOff45, ARRAY_LENGTH(scKoSrchOff45) },
2701     { scKoPat5, scKoSrchOff45, ARRAY_LENGTH(scKoSrchOff45) },
2702     { NULL,     NULL,          0                           }
2703 };
2704
2705 static const int32_t scKoStndOff01[] = { 3,  9 };
2706 static const int32_t scKoStndOff2[]  = { 5, 21 };
2707 static const int32_t scKoStndOff3[]  = { 25    };
2708 static const int32_t scKoStndOff45[] = { 7, 30 };
2709
2710 static const PatternAndOffsets scKoStndPatternsOffsets[] = {
2711     { scKoPat0, scKoStndOff01, ARRAY_LENGTH(scKoStndOff01) },
2712     { scKoPat1, scKoStndOff01, ARRAY_LENGTH(scKoStndOff01) },
2713     { scKoPat2, scKoStndOff2,  ARRAY_LENGTH(scKoStndOff2)  },
2714     { scKoPat3, scKoStndOff3,  ARRAY_LENGTH(scKoStndOff3)  },
2715     { scKoPat4, scKoStndOff45, ARRAY_LENGTH(scKoStndOff45) },
2716     { scKoPat5, scKoStndOff45, ARRAY_LENGTH(scKoStndOff45) },
2717     { NULL,     NULL,          0                           }
2718 };
2719
2720 typedef struct {
2721     const char *  locale;
2722     const UChar * text;
2723     const PatternAndOffsets * patternsAndOffsets;
2724 } TUSCItem;
2725
2726 static const TUSCItem tuscItems[] = {
2727     { "root",                  scKoText, scKoStndPatternsOffsets },
2728     { "root@collation=search", scKoText, scKoSrchPatternsOffsets },
2729     { "ko@collation=search",   scKoText, scKoSrchPatternsOffsets },
2730     { NULL,                    NULL,     NULL                    }
2731 };
2732
2733 static const UChar dummyPat[] = { 0x0061, 0 };
2734
2735 static void TestUsingSearchCollator(void)
2736 {
2737     const TUSCItem * tuscItemPtr;
2738     for (tuscItemPtr = tuscItems; tuscItemPtr->locale != NULL; tuscItemPtr++) {
2739         UErrorCode status = U_ZERO_ERROR;
2740         UCollator* ucol = ucol_open(tuscItemPtr->locale, &status);
2741         if ( U_SUCCESS(status) ) {
2742             UStringSearch* usrch = usearch_openFromCollator(dummyPat, -1, tuscItemPtr->text, -1, ucol, NULL, &status);
2743             if ( U_SUCCESS(status) ) {
2744                 const PatternAndOffsets * patternsOffsetsPtr;
2745                 for ( patternsOffsetsPtr = tuscItemPtr->patternsAndOffsets; patternsOffsetsPtr->pattern != NULL; patternsOffsetsPtr++) {
2746                     usearch_setPattern(usrch, patternsOffsetsPtr->pattern, -1, &status);
2747                     if ( U_SUCCESS(status) ) {
2748                         int32_t offset;
2749                         const int32_t * nextOffsetPtr;
2750                         const int32_t * limitOffsetPtr;
2751
2752                         usearch_reset(usrch);
2753                         nextOffsetPtr = patternsOffsetsPtr->offsets;
2754                         limitOffsetPtr = patternsOffsetsPtr->offsets + patternsOffsetsPtr->offsetsLen;
2755                         while (TRUE) {
2756                             offset = usearch_next(usrch, &status);
2757                             if ( U_FAILURE(status) || offset == USEARCH_DONE ) {
2758                                 break;
2759                             }
2760                             if ( nextOffsetPtr < limitOffsetPtr ) {
2761                                  if (offset != *nextOffsetPtr) {
2762                                      log_err("error, locale %s, expected usearch_next %d, got %d\n", tuscItemPtr->locale, *nextOffsetPtr, offset);
2763                                      nextOffsetPtr = limitOffsetPtr;
2764                                      break;
2765                                  }
2766                                  nextOffsetPtr++;
2767                             } else {
2768                                 log_err("error, locale %s, usearch_next returned more matches than expected\n", tuscItemPtr->locale );
2769                             }
2770                         }
2771                         if ( U_FAILURE(status) ) {
2772                             log_err("error, locale %s, usearch_next failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
2773                         } else if ( nextOffsetPtr < limitOffsetPtr ) {
2774                             log_err("error, locale %s, usearch_next returned fewer matches than expected\n", tuscItemPtr->locale );
2775                         }
2776
2777                         status = U_ZERO_ERROR;
2778                         usearch_reset(usrch);
2779                         nextOffsetPtr = patternsOffsetsPtr->offsets + patternsOffsetsPtr->offsetsLen;
2780                         limitOffsetPtr = patternsOffsetsPtr->offsets;
2781                         while (TRUE) {
2782                             offset = usearch_previous(usrch, &status);
2783                             if ( U_FAILURE(status) || offset == USEARCH_DONE ) {
2784                                 break;
2785                             }
2786                             if ( nextOffsetPtr > limitOffsetPtr ) {
2787                                 nextOffsetPtr--;
2788                                 if (offset != *nextOffsetPtr) {
2789                                      log_err("error, locale %s, expected usearch_previous %d, got %d\n", tuscItemPtr->locale, *nextOffsetPtr, offset);
2790                                      nextOffsetPtr = limitOffsetPtr;
2791                                       break;
2792                                 }
2793                             } else {
2794                                 log_err("error, locale %s, usearch_previous returned more matches than expected\n", tuscItemPtr->locale );
2795                             }
2796                         }
2797                         if ( U_FAILURE(status) ) {
2798                             log_err("error, locale %s, usearch_previous failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
2799                         } else if ( nextOffsetPtr > limitOffsetPtr ) {
2800                             log_err("error, locale %s, usearch_previous returned fewer matches than expected\n", tuscItemPtr->locale );
2801                         }
2802
2803                     } else {
2804                         log_err("error, locale %s, usearch_setPattern failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
2805                     }
2806                 }
2807                 usearch_close(usrch);
2808             } else {
2809                 log_err("error, locale %s, usearch_openFromCollator failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
2810             }
2811             ucol_close(ucol);
2812         } else {
2813             log_data_err("error, locale %s, ucol_open failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
2814         }
2815     }
2816 }
2817
2818
2819 static void TestPCEBuffer_with(const UChar *search, uint32_t searchLen, const UChar *source, uint32_t sourceLen) {
2820    UErrorCode icuStatus = U_ZERO_ERROR;
2821    UCollator *coll;
2822    const char *locale;
2823    UBreakIterator *ubrk;
2824    UStringSearch *usearch;
2825    int32_t match = 0;
2826
2827
2828    coll = ucol_openFromShortString( "LSK_AS_CX_EX_FX_HX_NX_S4",
2829                                     FALSE,
2830                                     NULL,
2831                                     &icuStatus );
2832    if ( U_FAILURE(icuStatus) )
2833    {
2834      log_data_err( "ucol_openFromShortString error %s\n" , u_errorName(icuStatus));
2835       goto exit;
2836    }
2837
2838    locale = ucol_getLocaleByType( coll,
2839                                   ULOC_VALID_LOCALE,
2840                                   &icuStatus );
2841    if ( U_FAILURE(icuStatus) )
2842    {
2843      log_err( "ucol_getLocaleByType error %s\n", u_errorName(icuStatus) );
2844       goto exit;
2845    }
2846
2847    log_verbose("locale=%s\n", locale);
2848
2849    ubrk = ubrk_open( UBRK_CHARACTER,
2850                      locale,
2851                      source,
2852                      sourceLen,
2853                      &icuStatus );
2854    if ( U_FAILURE(icuStatus) )
2855    {
2856      log_err( "ubrk_open error %s\n", u_errorName(icuStatus) );
2857       goto exit;
2858    }
2859
2860    usearch = usearch_openFromCollator( search,
2861                                        searchLen,
2862                                        source,
2863                                        sourceLen,
2864                                        coll,
2865                                        ubrk,
2866                                        &icuStatus );
2867    if ( U_FAILURE(icuStatus) )
2868    {
2869      log_err( "usearch_openFromCollator error %s\n", u_errorName(icuStatus) );
2870       goto exit;
2871    }
2872
2873    match = usearch_first( usearch,
2874                           &icuStatus );
2875    if ( U_FAILURE(icuStatus) )
2876    {
2877      log_err( "usearch_first error %s\n", u_errorName(icuStatus) );
2878      goto exit;
2879    }
2880
2881    if(match==0) {
2882      log_verbose("OK: match=%d\n", match);
2883    } else {
2884      log_err("Err: match expected 0 got %d\n", match);
2885    }
2886
2887    usearch_close(usearch);
2888    ubrk_close(ubrk);
2889    ucol_close(coll);
2890
2891 exit:
2892    return;
2893 }
2894
2895
2896 static void TestPCEBuffer_100df(void) {
2897   UChar search[] =
2898     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df }; /* 38 cp, 9 of them unpaired surrogates */
2899   UChar source[] =
2900     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df };
2901   uint32_t searchLen = sizeof(search)/sizeof(UChar);
2902   uint32_t sourceLen = sizeof(source)/sizeof(UChar);
2903   TestPCEBuffer_with(search,searchLen,source,sourceLen);
2904  }
2905
2906
2907 static void TestPCEBuffer_2surr(void) {
2908   UChar search[] =
2909     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff }; /* 38 cp, 9 of them unpaired surrogates */
2910   UChar source[] =
2911     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff };
2912   uint32_t searchLen = sizeof(search)/sizeof(UChar);
2913   uint32_t sourceLen = sizeof(source)/sizeof(UChar);
2914   TestPCEBuffer_with(search,searchLen,source,sourceLen);
2915 }
2916
2917 static void TestMatchFollowedByIgnorables(void) {
2918     /* test case for ticket#8482 */
2919     UChar search[] = { 0x00c9 };
2920     UChar source[] = { 0x00c9, 0x0000, 0x0041 };
2921     int32_t searchLen;
2922     int32_t sourceLen;
2923     UErrorCode icuStatus = U_ZERO_ERROR;
2924     UCollator *coll;
2925     const char *locale;
2926     UBreakIterator *ubrk;
2927     UStringSearch *usearch;
2928     int32_t match = 0;
2929     int32_t matchLength = 0;
2930     const int32_t expectedMatchLength = 1;
2931
2932     searchLen = sizeof(search)/sizeof(UChar);
2933     sourceLen = sizeof(source)/sizeof(UChar);
2934
2935     coll = ucol_openFromShortString("LHR_AN_CX_EX_FX_HX_NX_S3",
2936                                     FALSE,
2937                                     NULL,
2938                                     &icuStatus);
2939     if (U_FAILURE(icuStatus)) {
2940         log_data_err("ucol_openFromShortString error - %s\n", u_errorName(icuStatus));
2941     }
2942
2943     locale = ucol_getLocaleByType(coll,
2944                                     ULOC_VALID_LOCALE,
2945                                     &icuStatus);
2946     if (U_FAILURE(icuStatus)) {
2947         log_data_err("ucol_getLocaleByType error - %s\n", u_errorName(icuStatus));
2948     }
2949
2950     ubrk = ubrk_open(UBRK_CHARACTER,
2951                         locale,
2952                         source,
2953                         sourceLen,
2954                         &icuStatus);
2955     if (U_FAILURE(icuStatus)) {
2956         log_data_err("ubrk_open error - %s\n", u_errorName(icuStatus));
2957     }
2958
2959     usearch = usearch_openFromCollator(search,
2960                                         searchLen,
2961                                         source,
2962                                         sourceLen,
2963                                         coll,
2964                                         ubrk,
2965                                         &icuStatus);
2966     if (U_FAILURE(icuStatus)) {
2967         log_data_err("usearch_openFromCollator error - %s\n", u_errorName(icuStatus));
2968     }
2969
2970     match = usearch_first(usearch,
2971                             &icuStatus);
2972     if (U_FAILURE(icuStatus)) {
2973         log_data_err("usearch_first error - %s\n", u_errorName(icuStatus));
2974     } else {
2975
2976         log_verbose("match=%d\n", match);
2977
2978         matchLength = usearch_getMatchedLength(usearch);
2979
2980         if (matchLength != expectedMatchLength) {
2981             log_err("Error: matchLength=%d, expected=%d\n", matchLength, expectedMatchLength);
2982         }
2983     }
2984
2985     usearch_close(usearch);
2986     ubrk_close(ubrk);
2987     ucol_close(coll);
2988 }
2989
2990 /**
2991 * addSearchTest
2992 */
2993
2994 void addSearchTest(TestNode** root)
2995 {
2996     addTest(root, &TestStart, "tscoll/usrchtst/TestStart");
2997     addTest(root, &TestOpenClose, "tscoll/usrchtst/TestOpenClose");
2998     addTest(root, &TestInitialization, "tscoll/usrchtst/TestInitialization");
2999     addTest(root, &TestBasic, "tscoll/usrchtst/TestBasic");
3000     addTest(root, &TestNormExact, "tscoll/usrchtst/TestNormExact");
3001     addTest(root, &TestStrength, "tscoll/usrchtst/TestStrength");
3002     addTest(root, &TestBreakIterator, "tscoll/usrchtst/TestBreakIterator");
3003     addTest(root, &TestVariable, "tscoll/usrchtst/TestVariable");
3004     addTest(root, &TestOverlap, "tscoll/usrchtst/TestOverlap");
3005     addTest(root, &TestCollator, "tscoll/usrchtst/TestCollator");
3006     addTest(root, &TestPattern, "tscoll/usrchtst/TestPattern");
3007     addTest(root, &TestText, "tscoll/usrchtst/TestText");
3008     addTest(root, &TestCompositeBoundaries,
3009                                   "tscoll/usrchtst/TestCompositeBoundaries");
3010     addTest(root, &TestGetSetOffset, "tscoll/usrchtst/TestGetSetOffset");
3011     addTest(root, &TestGetSetAttribute,
3012                                       "tscoll/usrchtst/TestGetSetAttribute");
3013     addTest(root, &TestGetMatch, "tscoll/usrchtst/TestGetMatch");
3014     addTest(root, &TestSetMatch, "tscoll/usrchtst/TestSetMatch");
3015     addTest(root, &TestReset, "tscoll/usrchtst/TestReset");
3016     addTest(root, &TestSupplementary, "tscoll/usrchtst/TestSupplementary");
3017     addTest(root, &TestContraction, "tscoll/usrchtst/TestContraction");
3018     addTest(root, &TestIgnorable, "tscoll/usrchtst/TestIgnorable");
3019     addTest(root, &TestCanonical, "tscoll/usrchtst/TestCanonical");
3020     addTest(root, &TestNormCanonical, "tscoll/usrchtst/TestNormCanonical");
3021     addTest(root, &TestStrengthCanonical,
3022                                     "tscoll/usrchtst/TestStrengthCanonical");
3023     addTest(root, &TestBreakIteratorCanonical,
3024                                "tscoll/usrchtst/TestBreakIteratorCanonical");
3025     addTest(root, &TestVariableCanonical,
3026                                     "tscoll/usrchtst/TestVariableCanonical");
3027     addTest(root, &TestOverlapCanonical,
3028                                      "tscoll/usrchtst/TestOverlapCanonical");
3029     addTest(root, &TestCollatorCanonical,
3030                                     "tscoll/usrchtst/TestCollatorCanonical");
3031     addTest(root, &TestPatternCanonical,
3032                                      "tscoll/usrchtst/TestPatternCanonical");
3033     addTest(root, &TestTextCanonical, "tscoll/usrchtst/TestTextCanonical");
3034     addTest(root, &TestCompositeBoundariesCanonical,
3035                          "tscoll/usrchtst/TestCompositeBoundariesCanonical");
3036     addTest(root, &TestGetSetOffsetCanonical,
3037                                 "tscoll/usrchtst/TestGetSetOffsetCanonical");
3038     addTest(root, &TestSupplementaryCanonical,
3039                                "tscoll/usrchtst/TestSupplementaryCanonical");
3040     addTest(root, &TestContractionCanonical,
3041                                  "tscoll/usrchtst/TestContractionCanonical");
3042     addTest(root, &TestEnd, "tscoll/usrchtst/TestEnd");
3043     addTest(root, &TestNumeric, "tscoll/usrchtst/TestNumeric");
3044     addTest(root, &TestDiacriticMatch, "tscoll/usrchtst/TestDiacriticMatch");
3045     addTest(root, &TestForwardBackward, "tscoll/usrchtst/TestForwardBackward");
3046     addTest(root, &TestSearchForNull, "tscoll/usrchtst/TestSearchForNull");
3047     addTest(root, &TestStrengthIdentical, "tscoll/usrchtst/TestStrengthIdentical");
3048     addTest(root, &TestUsingSearchCollator, "tscoll/usrchtst/TestUsingSearchCollator");
3049     addTest(root, &TestPCEBuffer_100df, "tscoll/usrchtst/TestPCEBuffer/1_00df");
3050     addTest(root, &TestPCEBuffer_2surr, "tscoll/usrchtst/TestPCEBuffer/2_dfff");
3051     addTest(root, &TestMatchFollowedByIgnorables, "tscoll/usrchtst/TestMatchFollowedByIgnorables");
3052 }
3053
3054 #endif /* #if !UCONFIG_NO_COLLATION */