source/test/cintltst/usrchtst.c

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