← Back to branch summary

~ubuntu-branches/ubuntu/precise/icu/precise

« back to all changes in this revision

Viewing changes to source/test/cintltst/usrchtst.c

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2009-09-04 11:56:06 UTC
  • mfrom: (10.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20090904115606-sqxxuizelam5tozb
Tags: 4.2.1-3
http://bugs.debian.org/544799
Change install-doc target to not fail if there are subdirectories of
doc/html.  This is necessary to handle the doc/html/search directory
created by doxygen 3.6.1.  (Closes: #544799)

Show diffs side-by-side

added added

removed removed

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