← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/icu/gutsy-updates

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Jay Berkenbilt
  • Date: 2005-11-19 11:29:31 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20051119112931-vcizkrp10tli4enw
Tags: 3.4-3
Explicitly build with g++ 3.4.  The current ICU fails its test suite
with 4.0 but not with 3.4.  Future versions should work properly with
4.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/test/cintltst/usrchtst.c
1
 
/********************************************************************
2
 
 * Copyright (c) 2001, 
3
 
 * International Business Machines Corporation and others. 
4
 
 * All Rights Reserved.
5
 
 ********************************************************************
6
 
 * File usrchtst.c
7
 
 * Modification History:
8
 
 * Name           Date             Description
9
 
 * synwee         July 19 2001     creation
10
 
 ********************************************************************/
11
 
 
12
 
#include "unicode/usearch.h"
13
 
#include "unicode/ustring.h"
14
 
#include "ccolltst.h"
15
 
#include "cmemory.h"
16
 
#include <stdio.h>
17
 
#include "usrchdat.c"
18
 
 
19
 
static UBool      TOCLOSE_ = TRUE;
20
 
static UCollator *EN_US_; 
21
 
static UCollator *FR_FR_;
22
 
static UCollator *DE_;
23
 
static UCollator *ES_;
24
 
static UBreakIterator *EN_WORDBREAKER_;
25
 
static UBreakIterator *EN_CHARACTERBREAKER_;
26
 
 
27
 
/**
28
 
* Opening all static collators and break iterators
29
 
*/
30
 
static void open(void)
31
 
{
32
 
    if (TOCLOSE_) {
33
 
        UErrorCode  status = U_ZERO_ERROR;
34
 
        UChar      rules[1024];
35
 
        int32_t    rulelength = 0;
36
 
 
37
 
        EN_US_ = ucol_open("en_US", &status);
38
 
        FR_FR_ = ucol_open("fr_FR", &status);
39
 
        DE_ = ucol_open("de_DE", &status);
40
 
        ES_ = ucol_open("es_ES", &status);
41
 
    
42
 
        u_strcpy(rules, ucol_getRules(DE_, &rulelength));
43
 
        u_unescape(EXTRACOLLATIONRULE, rules + rulelength, 1024 - rulelength);
44
 
    
45
 
        ucol_close(DE_);
46
 
 
47
 
        DE_ = ucol_openRules(rules, u_strlen(rules), UCOL_ON, UCOL_TERTIARY,
48
 
                             (UParseError *)NULL, &status);
49
 
        u_strcpy(rules, ucol_getRules(ES_, &rulelength));
50
 
        u_unescape(EXTRACOLLATIONRULE, rules + rulelength, 1024 - rulelength);
51
 
    
52
 
        ucol_close(ES_);
53
 
        ES_ = ucol_openRules(rules, u_strlen(rules), UCOL_ON, UCOL_TERTIARY,
54
 
                             NULL, &status); 
55
 
        EN_WORDBREAKER_     = ubrk_open(UBRK_WORD, "en_US", NULL, 0, &status);
56
 
        EN_CHARACTERBREAKER_ = ubrk_open(UBRK_CHARACTER, "en_US", NULL, 0, 
57
 
                                        &status);
58
 
        TOCLOSE_ = TRUE;
59
 
    }
60
 
}
61
 
 
62
 
/**
63
 
* Start opening all static collators and break iterators
64
 
*/
65
 
static void TestStart(void)
66
 
{
67
 
    open();
68
 
    TOCLOSE_ = FALSE;
69
 
}
70
 
 
71
 
/**
72
 
* Closing all static collators and break iterators
73
 
*/
74
 
static void close(void)
75
 
{
76
 
    if (TOCLOSE_) {
77
 
        ucol_close(EN_US_);
78
 
        ucol_close(FR_FR_);
79
 
        ucol_close(DE_);
80
 
        ucol_close(ES_);
81
 
        ubrk_close(EN_WORDBREAKER_);
82
 
        ubrk_close(EN_CHARACTERBREAKER_);
83
 
    }
84
 
    TOCLOSE_ = FALSE;
85
 
}
86
 
 
87
 
/**
88
 
* End closing all static collators and break iterators
89
 
*/
90
 
static void TestEnd(void)
91
 
{
92
 
    TOCLOSE_ = TRUE;
93
 
    close();
94
 
    TOCLOSE_ = TRUE;
95
 
}
96
 
 
97
 
/**
98
 
* output UChar strings for printing.
99
 
*/
100
 
static char *toCharString(const UChar* unichars)
101
 
{
102
 
    static char result[1024];
103
 
    char *temp   = result;
104
 
    int   count  = 0;
105
 
    int   length = u_strlen(unichars);
106
 
 
107
 
    for (; count < length; count ++) {
108
 
        UChar ch = unichars[count];
109
 
        if (ch >= 0x20 && ch <= 0x7e) {
110
 
            *temp ++ = (char)ch;
111
 
        }
112
 
        else {
113
 
            char digit[5];
114
 
            int  zerosize;
115
 
            *temp = 0;
116
 
            strcat(temp, "\\u");
117
 
            temp = temp + 2;
118
 
            sprintf(digit, "%x", ch);
119
 
            zerosize = 4 - strlen(digit);
120
 
            while (zerosize != 0) {
121
 
                *temp ++ = '0';
122
 
                zerosize --;
123
 
            }
124
 
            *temp = 0;
125
 
            strcat(temp, digit);
126
 
            temp = temp + strlen(digit);
127
 
        }
128
 
    }
129
 
    *temp = 0;
130
 
 
131
 
    return result;
132
 
}
133
 
 
134
 
/**
135
 
* Getting the collator
136
 
*/
137
 
static UCollator *getCollator(const char *collator) 
138
 
{
139
 
    if (collator == NULL) {
140
 
        return EN_US_;
141
 
    }
142
 
    if (strcmp(collator, "fr") == 0) {
143
 
        return FR_FR_;
144
 
    }
145
 
    else if (strcmp(collator, "de") == 0) {
146
 
        return DE_;
147
 
    }
148
 
    else if (strcmp(collator, "es") == 0) {
149
 
        return ES_;
150
 
    }
151
 
    else {
152
 
        return EN_US_;
153
 
    }
154
 
}
155
 
 
156
 
/**
157
 
* Getting the breakiterator
158
 
*/
159
 
static UBreakIterator *getBreakIterator(const char *breaker) 
160
 
{
161
 
    if (breaker == NULL) {
162
 
        return NULL;
163
 
    }
164
 
    if (strcmp(breaker, "wordbreaker") == 0) {
165
 
        return EN_WORDBREAKER_;
166
 
    }
167
 
    else {
168
 
        return EN_CHARACTERBREAKER_;
169
 
    }
170
 
}
171
 
 
172
 
static void TestOpenClose(void) 
173
 
{
174
 
          UErrorCode      status    = U_ZERO_ERROR;
175
 
          UStringSearch  *result;
176
 
    const UChar           pattern[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
177
 
    const UChar           text[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67};
178
 
          UBreakIterator *breakiter = ubrk_open(UBRK_WORD, "en_US", 
179
 
                                                text, 6, &status);
180
 
    /* testing null arguments */
181
 
    result = usearch_open(NULL, 0, NULL, 0, NULL, NULL, &status);
182
 
    if (U_SUCCESS(status) || result != NULL) {
183
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
184
 
    }
185
 
    status = U_ZERO_ERROR;
186
 
    result = usearch_openFromCollator(NULL, 0, NULL, 0, NULL, NULL, &status);
187
 
    if (U_SUCCESS(status) || result != NULL) {
188
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
189
 
    }
190
 
    
191
 
    status = U_ZERO_ERROR;
192
 
    result = usearch_open(pattern, 3, NULL, 0, NULL, NULL, &status);
193
 
    if (U_SUCCESS(status) || result != NULL) {
194
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
195
 
    }
196
 
    status = U_ZERO_ERROR;
197
 
    result = usearch_openFromCollator(pattern, 3, NULL, 0, NULL, NULL, 
198
 
                                      &status);
199
 
    if (U_SUCCESS(status) || result != NULL) {
200
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
201
 
    }
202
 
    
203
 
    status = U_ZERO_ERROR;
204
 
    result = usearch_open(pattern, 3, text, 6, NULL, NULL, &status);
205
 
    if (U_SUCCESS(status) || result != NULL) {
206
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
207
 
    }
208
 
    status = U_ZERO_ERROR;
209
 
    result = usearch_openFromCollator(pattern, 3, text, 6, NULL, NULL, 
210
 
                                      &status);
211
 
    if (U_SUCCESS(status) || result != NULL) {
212
 
        log_err("Error: NULL arguments should produce an error and a NULL result\n");
213
 
    }
214
 
    
215
 
    status = U_ZERO_ERROR;
216
 
    result = usearch_open(pattern, 3, text, 6, "en_US", NULL, &status);
217
 
    if (U_FAILURE(status) || result == NULL) {
218
 
        log_err("Error: NULL break iterator is valid for opening search\n");
219
 
    }
220
 
    else {
221
 
        usearch_close(result);
222
 
    }
223
 
    open();
224
 
    status = U_ZERO_ERROR;
225
 
    result = usearch_openFromCollator(pattern, 3, text, 6, EN_US_, NULL, 
226
 
                                      &status);
227
 
    if (U_FAILURE(status) || result == NULL) {
228
 
        log_err("Error: NULL break iterator is valid for opening search\n");
229
 
    }
230
 
    else {
231
 
        usearch_close(result);
232
 
    }
233
 
 
234
 
    status = U_ZERO_ERROR;
235
 
    result = usearch_open(pattern, 3, text, 6, "en_US", breakiter, &status);
236
 
    if (U_FAILURE(status) || result == NULL) {
237
 
        log_err("Error: Break iterator is valid for opening search\n");
238
 
    }
239
 
    else {
240
 
        usearch_close(result);
241
 
    }
242
 
    status = U_ZERO_ERROR;
243
 
    result = usearch_openFromCollator(pattern, 3, text, 6, EN_US_, breakiter, 
244
 
                                      &status);
245
 
    if (U_FAILURE(status) || result == NULL) {
246
 
        log_err("Error: Break iterator is valid for opening search\n");
247
 
    }
248
 
    else {
249
 
        usearch_close(result);
250
 
    }
251
 
    ubrk_close(breakiter);
252
 
    close();
253
 
}
254
 
 
255
 
static void TestInitialization(void) 
256
 
{
257
 
          UErrorCode      status = U_ZERO_ERROR;
258
 
          UChar           pattern[512];
259
 
    const UChar           text[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
260
 
    UStringSearch  *result;
261
 
 
262
 
    /* simple test on the pattern ce construction */
263
 
    pattern[0] = 0x41;
264
 
    pattern[1] = 0x42;
265
 
    open();
266
 
    result = usearch_openFromCollator(pattern, 2, text, 3, EN_US_, NULL, 
267
 
                                      &status);
268
 
    if (U_FAILURE(status)) {
269
 
        log_err("Error opening search %s\n", u_errorName(status));
270
 
    }
271
 
    usearch_close(result);
272
 
 
273
 
    /* testing if an extremely large pattern will fail the initialization */
274
 
    uprv_memset(pattern, 0x41, 512);
275
 
    result = usearch_openFromCollator(pattern, 512, text, 3, EN_US_, NULL, 
276
 
                                      &status);
277
 
    if (U_FAILURE(status)) {
278
 
        log_err("Error opening search %s\n", u_errorName(status));
279
 
    }
280
 
    usearch_close(result);
281
 
    close();
282
 
}
283
 
 
284
 
static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
285
 
                                          const SearchData     search)
286
 
{
287
 
    int         count       = 0;
288
 
    int         matchlimit  = 0;
289
 
    UErrorCode  status      = U_ZERO_ERROR;
290
 
    int32_t matchindex  = search.offset[count];
291
 
    int32_t     textlength;
292
 
    UChar       matchtext[128];
293
 
 
294
 
    if (usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
295
 
        usearch_getMatchedLength(strsrch) != 0) {
296
 
        log_err("Error with the initialization of match start and length\n");
297
 
    }
298
 
    /* start of following matches */
299
 
    while (U_SUCCESS(status) && matchindex >= 0) {
300
 
        uint32_t matchlength = search.size[count];
301
 
        usearch_next(strsrch, &status);
302
 
        if (matchindex != usearch_getMatchedStart(strsrch) || 
303
 
            matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
304
 
            char *str = toCharString(usearch_getText(strsrch, &textlength));
305
 
            log_err("Text: %s\n", str);
306
 
            str = toCharString(usearch_getPattern(strsrch, &textlength));
307
 
            log_err("Pattern: %s\n", str);
308
 
            log_err("Error following match found at %d %d\n", 
309
 
                    usearch_getMatchedStart(strsrch), 
310
 
                    usearch_getMatchedLength(strsrch));
311
 
            return FALSE;
312
 
        }
313
 
        count ++;
314
 
        
315
 
        if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
316
 
            (int32_t) matchlength || U_FAILURE(status) ||
317
 
            memcmp(matchtext, 
318
 
                   usearch_getText(strsrch, &textlength) + matchindex,
319
 
                   matchlength * sizeof(UChar)) != 0) {
320
 
            log_err("Error getting following matched text\n");
321
 
        }
322
 
 
323
 
        matchindex = search.offset[count];
324
 
    }
325
 
    usearch_next(strsrch, &status);
326
 
    if ((uint32_t)usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
327
 
        usearch_getMatchedLength(strsrch) != 0) {
328
 
        char *str = toCharString(usearch_getText(strsrch, &textlength));
329
 
        log_err("Text: %s\n", str);
330
 
        str = toCharString(usearch_getPattern(strsrch, &textlength));
331
 
        log_err("Pattern: %s\n", str);
332
 
        log_err("Error following match found at %d %d\n", 
333
 
                    usearch_getMatchedStart(strsrch), 
334
 
                    usearch_getMatchedLength(strsrch));
335
 
        return FALSE;
336
 
    }
337
 
    /* start of preceding matches */
338
 
    count = count == 0 ? 0 : count - 1;
339
 
    matchlimit = count;
340
 
    matchindex = search.offset[count];
341
 
 
342
 
    while (U_SUCCESS(status) && matchindex >= 0) {
343
 
        uint32_t matchlength = search.size[count];
344
 
        usearch_previous(strsrch, &status);
345
 
        if (matchindex != usearch_getMatchedStart(strsrch) || 
346
 
            matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
347
 
            char *str = toCharString(usearch_getText(strsrch, &textlength));
348
 
            log_err("Text: %s\n", str);
349
 
            str = toCharString(usearch_getPattern(strsrch, &textlength));
350
 
            log_err("Pattern: %s\n", str);
351
 
            log_err("Error preceding match found at %d %d\n", 
352
 
                    usearch_getMatchedStart(strsrch), 
353
 
                    usearch_getMatchedLength(strsrch));
354
 
            return FALSE;
355
 
        }
356
 
        
357
 
        if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
358
 
            (int32_t) matchlength || U_FAILURE(status) ||
359
 
            memcmp(matchtext, 
360
 
                   usearch_getText(strsrch, &textlength) + matchindex,
361
 
                   matchlength * sizeof(UChar)) != 0) {
362
 
            log_err("Error getting preceding matched text\n");
363
 
        }
364
 
 
365
 
        matchindex = count > 0 ? search.offset[count - 1] : -1;
366
 
        count --;
367
 
    }
368
 
    usearch_previous(strsrch, &status);
369
 
    if ((uint32_t)usearch_getMatchedStart(strsrch) != USEARCH_DONE ||
370
 
        usearch_getMatchedLength(strsrch) != 0) {
371
 
        char *str = toCharString(usearch_getText(strsrch, &textlength));
372
 
        log_err("Text: %s\n", str);
373
 
        str = toCharString(usearch_getPattern(strsrch, &textlength));
374
 
        log_err("Pattern: %s\n", str);
375
 
        log_err("Error preceding match found at %d %d\n", 
376
 
                    usearch_getMatchedStart(strsrch), 
377
 
                    usearch_getMatchedLength(strsrch));
378
 
        return FALSE;
379
 
    }
380
 
 
381
 
    return TRUE;
382
 
}
383
 
 
384
 
static UBool assertEqual(const SearchData search)
385
 
{
386
 
    UErrorCode      status      = U_ZERO_ERROR;
387
 
    UChar           pattern[32];
388
 
    UChar           text[128];
389
 
    UCollator      *collator = getCollator(search.collator);
390
 
    UBreakIterator *breaker  = getBreakIterator(search.breaker);
391
 
    UStringSearch  *strsrch; 
392
 
    
393
 
    u_unescape(search.text, text, 128);
394
 
    u_unescape(search.pattern, pattern, 32);
395
 
    ucol_setStrength(collator, search.strength);
396
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
397
 
                                       breaker, &status);
398
 
    if (U_FAILURE(status)) {
399
 
        log_err("Error opening string search %s\n", u_errorName(status));
400
 
        return FALSE;
401
 
    }   
402
 
    
403
 
    if (!assertEqualWithUStringSearch(strsrch, search)) {
404
 
        ucol_setStrength(collator, UCOL_TERTIARY);
405
 
        usearch_close(strsrch);
406
 
        return FALSE;
407
 
    }
408
 
    ucol_setStrength(collator, UCOL_TERTIARY);
409
 
    usearch_close(strsrch);
410
 
    return TRUE;
411
 
}
412
 
 
413
 
static UBool assertCanonicalEqual(const SearchData search)
414
 
{
415
 
    UErrorCode      status      = U_ZERO_ERROR;
416
 
    UChar           pattern[32];
417
 
    UChar           text[128];
418
 
    UCollator      *collator = getCollator(search.collator);
419
 
    UBreakIterator *breaker  = getBreakIterator(search.breaker);
420
 
    UStringSearch  *strsrch; 
421
 
    
422
 
    u_unescape(search.text, text, 128);
423
 
    u_unescape(search.pattern, pattern, 32);
424
 
    ucol_setStrength(collator, search.strength);
425
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
426
 
                                       breaker, &status);
427
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON,
428
 
                         &status);
429
 
    if (U_FAILURE(status)) {
430
 
        log_err("Error opening string search %s\n", u_errorName(status));
431
 
        return FALSE;
432
 
    }   
433
 
    
434
 
    if (!assertEqualWithUStringSearch(strsrch, search)) {
435
 
        ucol_setStrength(collator, UCOL_TERTIARY);
436
 
        usearch_close(strsrch);
437
 
        return FALSE;
438
 
    }
439
 
    ucol_setStrength(collator, UCOL_TERTIARY);
440
 
    usearch_close(strsrch);
441
 
    return TRUE;
442
 
}
443
 
 
444
 
static UBool assertEqualWithAttribute(const SearchData            search, 
445
 
                                            USearchAttributeValue canonical,
446
 
                                            USearchAttributeValue overlap)
447
 
{
448
 
    UErrorCode      status      = U_ZERO_ERROR;
449
 
    UChar           pattern[32];
450
 
    UChar           text[128];
451
 
    UCollator      *collator = getCollator(search.collator);
452
 
    UBreakIterator *breaker  = getBreakIterator(search.breaker);
453
 
    UStringSearch  *strsrch; 
454
 
    
455
 
    u_unescape(search.text, text, 128);
456
 
    u_unescape(search.pattern, pattern, 32);
457
 
    ucol_setStrength(collator, search.strength);
458
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
459
 
                                       breaker, &status);
460
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, canonical, 
461
 
                         &status);
462
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, overlap, &status);
463
 
    
464
 
    if (U_FAILURE(status)) {
465
 
        log_err("Error opening string search %s\n", u_errorName(status));
466
 
        return FALSE;
467
 
    }   
468
 
    
469
 
    if (!assertEqualWithUStringSearch(strsrch, search)) {
470
 
            ucol_setStrength(collator, UCOL_TERTIARY);
471
 
            usearch_close(strsrch);
472
 
            return FALSE;
473
 
    }
474
 
    ucol_setStrength(collator, UCOL_TERTIARY);
475
 
    usearch_close(strsrch);
476
 
    return TRUE;
477
 
}
478
 
 
479
 
static void TestBasic(void) 
480
 
{
481
 
    int count = 0;
482
 
    open();
483
 
    while (BASIC[count].text != NULL) {
484
 
        if (!assertEqual(BASIC[count])) {
485
 
            log_err("Error at test number %d\n", count);
486
 
        }
487
 
        count ++;
488
 
    }
489
 
    close();
490
 
}
491
 
 
492
 
static void TestNormExact(void) 
493
 
{
494
 
    int count = 0;
495
 
    UErrorCode status = U_ZERO_ERROR;
496
 
    open();
497
 
    ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
498
 
    if (U_FAILURE(status)) {
499
 
        log_err("Error setting collation normalization %s\n", 
500
 
            u_errorName(status));
501
 
    }
502
 
    while (BASIC[count].text != NULL) {
503
 
        if (!assertEqual(BASIC[count])) {
504
 
            log_err("Error at test number %d\n", count);
505
 
        }
506
 
        count ++;
507
 
    }
508
 
    count = 0;
509
 
    while (NORMEXACT[count].text != NULL) {
510
 
        if (!assertEqual(NORMEXACT[count])) {
511
 
            log_err("Error at test number %d\n", count);
512
 
        }
513
 
        count ++;
514
 
    }
515
 
    ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
516
 
    count = 0;
517
 
    while (NONNORMEXACT[count].text != NULL) {
518
 
        if (!assertEqual(NONNORMEXACT[count])) {
519
 
            log_err("Error at test number %d\n", count);
520
 
        }
521
 
        count ++;
522
 
    }
523
 
    close();
524
 
}
525
 
 
526
 
static void TestStrength(void) 
527
 
{
528
 
    int count = 0;
529
 
    open();
530
 
    while (STRENGTH[count].text != NULL) {
531
 
        if (!assertEqual(STRENGTH[count])) {
532
 
            log_err("Error at test number %d\n", count);
533
 
        }
534
 
        count ++;
535
 
    }
536
 
    close();
537
 
}
538
 
 
539
 
static void TestBreakIterator(void) {
540
 
    UErrorCode      status      = U_ZERO_ERROR;
541
 
    UStringSearch  *strsrch; 
542
 
    UChar           text[128];
543
 
    UChar           pattern[32];
544
 
    int             count = 0;
545
 
 
546
 
    open();
547
 
    if (usearch_getBreakIterator(NULL) != NULL) {
548
 
        log_err("Expected NULL breakiterator from NULL string search\n");
549
 
    }
550
 
    u_unescape(BREAKITERATOREXACT[0].text, text, 128);
551
 
    u_unescape(BREAKITERATOREXACT[0].pattern, pattern, 32);
552
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, NULL, 
553
 
                                       &status);
554
 
    if (U_FAILURE(status)) {
555
 
        log_err("Error opening string search %s\n", u_errorName(status));
556
 
        goto ENDTESTBREAKITERATOR;
557
 
    }
558
 
    
559
 
    usearch_setBreakIterator(strsrch, NULL, &status);
560
 
    if (U_FAILURE(status) || usearch_getBreakIterator(strsrch) != NULL) {
561
 
        log_err("Error usearch_getBreakIterator returned wrong object");
562
 
        goto ENDTESTBREAKITERATOR;
563
 
    }
564
 
 
565
 
    usearch_setBreakIterator(strsrch, EN_CHARACTERBREAKER_, &status);
566
 
    if (U_FAILURE(status) || 
567
 
        usearch_getBreakIterator(strsrch) != EN_CHARACTERBREAKER_) {
568
 
        log_err("Error usearch_getBreakIterator returned wrong object");
569
 
        goto ENDTESTBREAKITERATOR;
570
 
    }
571
 
    
572
 
    usearch_setBreakIterator(strsrch, EN_WORDBREAKER_, &status);
573
 
    if (U_FAILURE(status) || 
574
 
        usearch_getBreakIterator(strsrch) != EN_WORDBREAKER_) {
575
 
        log_err("Error usearch_getBreakIterator returned wrong object");
576
 
        goto ENDTESTBREAKITERATOR;
577
 
    }
578
 
 
579
 
    usearch_close(strsrch);
580
 
 
581
 
    count = 0;
582
 
    while (count < 4) {
583
 
        /* 0-3 test are fixed */
584
 
        const SearchData     *search   = &(BREAKITERATOREXACT[count]);     
585
 
              UCollator      *collator = getCollator(search->collator);
586
 
              UBreakIterator *breaker  = getBreakIterator(search->breaker);
587
 
    
588
 
        u_unescape(search->text, text, 128);
589
 
        u_unescape(search->pattern, pattern, 32);
590
 
        ucol_setStrength(collator, search->strength);
591
 
        
592
 
        strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
593
 
                                           breaker, &status);
594
 
        if (U_FAILURE(status) || 
595
 
            usearch_getBreakIterator(strsrch) != breaker) {
596
 
            log_err("Error setting break iterator\n");
597
 
            if (strsrch != NULL) {
598
 
                usearch_close(strsrch);
599
 
            }
600
 
        }
601
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
602
 
            ucol_setStrength(collator, UCOL_TERTIARY);
603
 
            usearch_close(strsrch);
604
 
            goto ENDTESTBREAKITERATOR;
605
 
        }
606
 
        search   = &(BREAKITERATOREXACT[count + 1]);
607
 
        breaker  = getBreakIterator(search->breaker);
608
 
        usearch_setBreakIterator(strsrch, breaker, &status);
609
 
        if (U_FAILURE(status) || 
610
 
            usearch_getBreakIterator(strsrch) != breaker) {
611
 
            log_err("Error setting break iterator\n");
612
 
            usearch_close(strsrch);
613
 
            goto ENDTESTBREAKITERATOR;
614
 
        }
615
 
        usearch_reset(strsrch);
616
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
617
 
             log_err("Error at test number %d\n", count);
618
 
             goto ENDTESTBREAKITERATOR;
619
 
        }
620
 
        usearch_close(strsrch);
621
 
        count += 2;
622
 
    }
623
 
    count = 0;
624
 
    while (BREAKITERATOREXACT[count].text != NULL) {
625
 
         if (!assertEqual(BREAKITERATOREXACT[count])) {
626
 
             log_err("Error at test number %d\n", count);
627
 
             goto ENDTESTBREAKITERATOR;
628
 
         }
629
 
         count ++;
630
 
    }
631
 
    
632
 
ENDTESTBREAKITERATOR:
633
 
    close();
634
 
}
635
 
 
636
 
static void TestVariable(void) 
637
 
{
638
 
    int count = 0;
639
 
    UErrorCode status = U_ZERO_ERROR;
640
 
    open();
641
 
    ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
642
 
    if (U_FAILURE(status)) {
643
 
        log_err("Error setting collation alternate attribute %s\n", 
644
 
            u_errorName(status));
645
 
    }
646
 
    while (VARIABLE[count].text != NULL) {
647
 
        log_verbose("variable %d\n", count);
648
 
        if (!assertEqual(VARIABLE[count])) {
649
 
            log_err("Error at test number %d\n", count);
650
 
        }
651
 
        count ++;
652
 
    }
653
 
    ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, 
654
 
                      UCOL_NON_IGNORABLE, &status);
655
 
    close();
656
 
}
657
 
 
658
 
static void TestOverlap(void)
659
 
{
660
 
    int count = 0;
661
 
    open();
662
 
    while (OVERLAP[count].text != NULL) {
663
 
        if (!assertEqualWithAttribute(OVERLAP[count], USEARCH_OFF, 
664
 
                                      USEARCH_ON)) {
665
 
            log_err("Error at overlap test number %d\n", count);
666
 
        }
667
 
        count ++;
668
 
    }    
669
 
    count = 0;
670
 
    while (NONOVERLAP[count].text != NULL) {
671
 
        if (!assertEqual(NONOVERLAP[count])) {
672
 
            log_err("Error at non overlap test number %d\n", count);
673
 
        }
674
 
        count ++;
675
 
    }
676
 
 
677
 
    count = 0;
678
 
    while (count < 1) {
679
 
              UChar           pattern[32];
680
 
              UChar           text[128];
681
 
        const SearchData     *search   = &(OVERLAP[count]);     
682
 
              UCollator      *collator = getCollator(search->collator);
683
 
              UStringSearch  *strsrch; 
684
 
              UErrorCode      status   = U_ZERO_ERROR;
685
 
    
686
 
        u_unescape(search->text, text, 128);
687
 
        u_unescape(search->pattern, pattern, 32);
688
 
        strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
689
 
                                           NULL, &status);
690
 
        usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
691
 
        if (U_FAILURE(status) ||
692
 
            usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
693
 
            log_err("Error setting overlap option\n");
694
 
        }
695
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
696
 
            usearch_close(strsrch);
697
 
            return;
698
 
        }
699
 
        search   = &(NONOVERLAP[count]);
700
 
        usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
701
 
        if (U_FAILURE(status) ||
702
 
            usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
703
 
            log_err("Error setting overlap option\n");
704
 
        }
705
 
        usearch_reset(strsrch);
706
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
707
 
            usearch_close(strsrch);
708
 
            log_err("Error at test number %d\n", count);
709
 
         }
710
 
 
711
 
        count ++;
712
 
        usearch_close(strsrch);
713
 
    }
714
 
    close();
715
 
}
716
 
 
717
 
static void TestCollator(void) 
718
 
{
719
 
    /* test collator that thinks "o" and "p" are the same thing */
720
 
          UChar          rules[32];
721
 
          UCollator     *tailored = NULL; 
722
 
          UErrorCode     status   = U_ZERO_ERROR;
723
 
          UChar          pattern[32];
724
 
          UChar          text[128];
725
 
          UStringSearch *strsrch; 
726
 
          
727
 
    text[0] = 0x41;
728
 
    text[1] = 0x42;
729
 
    text[2] = 0x43;
730
 
    text[3] = 0x44;
731
 
    text[4] = 0x45;
732
 
    pattern[0] = 0x62;
733
 
    pattern[1] = 0x63;
734
 
    strsrch  = usearch_open(pattern, 2, text, 5, "en_US",  NULL,  &status);
735
 
    tailored = usearch_getCollator(strsrch);
736
 
    if (usearch_next(strsrch, &status) != -1) {
737
 
        log_err("Error: Found case insensitive match, when we shouldn't\n");
738
 
    }
739
 
    ucol_setStrength(tailored, UCOL_PRIMARY);
740
 
    usearch_reset(strsrch);
741
 
    if (usearch_next(strsrch, &status) != 1) {
742
 
        log_err("Error: Found case insensitive match not found\n");
743
 
    }
744
 
    usearch_close(strsrch);
745
 
 
746
 
    open();
747
 
 
748
 
    if (usearch_getCollator(NULL) != NULL) {
749
 
        log_err("Expected NULL collator from NULL string search\n");
750
 
    }
751
 
    u_unescape(COLLATOR[0].text, text, 128);
752
 
    u_unescape(COLLATOR[0].pattern, pattern, 32);
753
 
 
754
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
755
 
                                       NULL, &status);
756
 
    if (U_FAILURE(status)) {
757
 
        log_err("Error opening string search %s\n", u_errorName(status));
758
 
    }
759
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATOR[0])) {
760
 
        goto ENDTESTCOLLATOR;
761
 
    }
762
 
    
763
 
    u_unescape(TESTCOLLATORRULE, rules, 32);
764
 
    tailored = ucol_openRules(rules, -1, UCOL_ON, COLLATOR[1].strength, 
765
 
                              NULL, &status);
766
 
    if (U_FAILURE(status)) {
767
 
        log_err("Error opening rule based collator %s\n", u_errorName(status));
768
 
    }
769
 
 
770
 
    usearch_setCollator(strsrch, tailored, &status);
771
 
    if (U_FAILURE(status) || usearch_getCollator(strsrch) != tailored) {
772
 
        log_err("Error setting rule based collator\n");
773
 
    }
774
 
    usearch_reset(strsrch);
775
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATOR[1])) {
776
 
        goto ENDTESTCOLLATOR;
777
 
    }
778
 
        
779
 
    usearch_setCollator(strsrch, EN_US_, &status);
780
 
    usearch_reset(strsrch);
781
 
    if (U_FAILURE(status) || usearch_getCollator(strsrch) != EN_US_) {
782
 
        log_err("Error setting rule based collator\n");
783
 
    }
784
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATOR[0])) {
785
 
        goto ENDTESTCOLLATOR;
786
 
    }
787
 
    
788
 
ENDTESTCOLLATOR:
789
 
    usearch_close(strsrch);
790
 
    if (tailored != NULL) {
791
 
        ucol_close(tailored);
792
 
    }
793
 
    close();
794
 
}
795
 
 
796
 
static void TestPattern(void)
797
 
{
798
 
          UStringSearch *strsrch; 
799
 
          UChar          pattern[32];
800
 
          UChar          bigpattern[512];
801
 
          UChar          text[128];
802
 
    const UChar         *temp;
803
 
          int32_t        templength;
804
 
          UErrorCode     status = U_ZERO_ERROR;
805
 
 
806
 
    open();
807
 
    if (usearch_getPattern(NULL, &templength) != NULL) {
808
 
        log_err("Error NULL string search expected returning NULL pattern\n");
809
 
    }
810
 
    usearch_setPattern(NULL, pattern, 3, &status);
811
 
    if (U_SUCCESS(status)) {
812
 
        log_err("Error expected setting pattern in NULL strings search\n");
813
 
    }
814
 
    status = U_ZERO_ERROR;
815
 
    u_unescape(PATTERN[0].text, text, 128);
816
 
    u_unescape(PATTERN[0].pattern, pattern, 32);
817
 
 
818
 
    ucol_setStrength(EN_US_, PATTERN[0].strength);
819
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
820
 
                                       NULL, &status);
821
 
 
822
 
    status = U_ZERO_ERROR;
823
 
    usearch_setPattern(strsrch, NULL, 3, &status);
824
 
    if (U_SUCCESS(status)) {
825
 
        log_err("Error expected setting NULL pattern in strings search\n");
826
 
    }
827
 
    status = U_ZERO_ERROR;
828
 
    usearch_setPattern(strsrch, pattern, 0, &status);
829
 
    if (U_SUCCESS(status)) {
830
 
        log_err("Error expected setting pattern with length 0 in strings search\n");
831
 
    }
832
 
    status = U_ZERO_ERROR;
833
 
    if (U_FAILURE(status)) {
834
 
        log_err("Error opening string search %s\n", u_errorName(status));
835
 
        goto ENDTESTPATTERN;
836
 
    }
837
 
    temp = usearch_getPattern(strsrch, &templength);
838
 
    if (u_strcmp(pattern, temp) != 0) {
839
 
        log_err("Error setting pattern\n");
840
 
    }
841
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERN[0])) {
842
 
        goto ENDTESTPATTERN;
843
 
    }
844
 
 
845
 
    u_unescape(PATTERN[1].pattern, pattern, 32);
846
 
    usearch_setPattern(strsrch, pattern, -1, &status);
847
 
    temp = usearch_getPattern(strsrch, &templength);
848
 
    if (u_strcmp(pattern, temp) != 0) {
849
 
        log_err("Error setting pattern\n");
850
 
        goto ENDTESTPATTERN;
851
 
    }
852
 
    usearch_reset(strsrch);
853
 
    if (U_FAILURE(status)) {
854
 
        log_err("Error setting pattern %s\n", u_errorName(status));
855
 
    }
856
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERN[1])) {
857
 
        goto ENDTESTPATTERN;
858
 
    }
859
 
 
860
 
    u_unescape(PATTERN[0].pattern, pattern, 32);
861
 
    usearch_setPattern(strsrch, pattern, -1, &status);
862
 
    temp = usearch_getPattern(strsrch, &templength);
863
 
    if (u_strcmp(pattern, temp) != 0) {
864
 
        log_err("Error setting pattern\n");
865
 
        goto ENDTESTPATTERN;
866
 
    }
867
 
    usearch_reset(strsrch);
868
 
    if (U_FAILURE(status)) {
869
 
        log_err("Error setting pattern %s\n", u_errorName(status));
870
 
    }
871
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERN[0])) {
872
 
        goto ENDTESTPATTERN;
873
 
    }
874
 
    /* enormous pattern size to see if this crashes */
875
 
    for (templength = 0; templength != 512; templength ++) {
876
 
        bigpattern[templength] = 0x61;
877
 
    }
878
 
    bigpattern[511] = 0;
879
 
    usearch_setPattern(strsrch, bigpattern, -1, &status);
880
 
    if (U_FAILURE(status)) {
881
 
        log_err("Error setting pattern with size 512, %s \n", 
882
 
            u_errorName(status));
883
 
    }
884
 
ENDTESTPATTERN:
885
 
    ucol_setStrength(EN_US_, UCOL_TERTIARY);
886
 
    if (strsrch != NULL) {
887
 
        usearch_close(strsrch);
888
 
    }
889
 
    close();
890
 
}
891
 
 
892
 
static void TestText(void) 
893
 
{
894
 
          UStringSearch *strsrch; 
895
 
          UChar          pattern[32];
896
 
          UChar          text[128];
897
 
    const UChar         *temp;
898
 
          int32_t        templength;
899
 
          UErrorCode     status = U_ZERO_ERROR;
900
 
 
901
 
    u_unescape(TEXT[0].text, text, 128);
902
 
    u_unescape(TEXT[0].pattern, pattern, 32);
903
 
 
904
 
    open();
905
 
 
906
 
    if (usearch_getText(NULL, &templength) != NULL) {
907
 
        log_err("Error NULL string search should return NULL text\n");
908
 
    }
909
 
 
910
 
    usearch_setText(NULL, text, 10, &status);
911
 
    if (U_SUCCESS(status)) {
912
 
        log_err("Error NULL string search should have an error when setting text\n");
913
 
    }
914
 
 
915
 
    status = U_ZERO_ERROR;
916
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
917
 
                                       NULL, &status);
918
 
 
919
 
    if (U_FAILURE(status)) {
920
 
        log_err("Error opening string search %s\n", u_errorName(status));
921
 
        goto ENDTESTPATTERN;
922
 
    }
923
 
    temp = usearch_getText(strsrch, &templength);
924
 
    if (u_strcmp(text, temp) != 0) {
925
 
        log_err("Error setting text\n");
926
 
    }
927
 
    if (!assertEqualWithUStringSearch(strsrch, TEXT[0])) {
928
 
        goto ENDTESTPATTERN;
929
 
    }
930
 
 
931
 
    u_unescape(TEXT[1].text, text, 32);
932
 
    usearch_setText(strsrch, text, -1, &status);
933
 
    temp = usearch_getText(strsrch, &templength);
934
 
    if (u_strcmp(text, temp) != 0) {
935
 
        log_err("Error setting text\n");
936
 
        goto ENDTESTPATTERN;
937
 
    }
938
 
    if (U_FAILURE(status)) {
939
 
        log_err("Error setting text %s\n", u_errorName(status));
940
 
    }
941
 
    if (!assertEqualWithUStringSearch(strsrch, TEXT[1])) {
942
 
        goto ENDTESTPATTERN;
943
 
    }
944
 
 
945
 
    u_unescape(TEXT[0].text, text, 32);
946
 
    usearch_setText(strsrch, text, -1, &status);
947
 
    temp = usearch_getText(strsrch, &templength);
948
 
    if (u_strcmp(text, temp) != 0) {
949
 
        log_err("Error setting text\n");
950
 
        goto ENDTESTPATTERN;
951
 
    }
952
 
    if (U_FAILURE(status)) {
953
 
        log_err("Error setting pattern %s\n", u_errorName(status));
954
 
    }
955
 
    if (!assertEqualWithUStringSearch(strsrch, TEXT[0])) {
956
 
        goto ENDTESTPATTERN;
957
 
    }
958
 
ENDTESTPATTERN:
959
 
    if (strsrch != NULL) {
960
 
        usearch_close(strsrch);
961
 
    }
962
 
    close();
963
 
}
964
 
 
965
 
static void TestCompositeBoundaries(void) 
966
 
{
967
 
    int count = 0;
968
 
    open();
969
 
    while (COMPOSITEBOUNDARIES[count].text != NULL) { 
970
 
        log_verbose("composite %d\n", count);
971
 
        if (!assertEqual(COMPOSITEBOUNDARIES[count])) {
972
 
            log_err("Error at test number %d\n", count);
973
 
        }
974
 
        count ++;
975
 
    } 
976
 
    close();
977
 
}
978
 
 
979
 
static void TestGetSetOffset(void)
980
 
{
981
 
    int            index   = 0;
982
 
    UChar          pattern[32];
983
 
    UChar          text[128];
984
 
    UErrorCode     status  = U_ZERO_ERROR;
985
 
    UStringSearch *strsrch;
986
 
 
987
 
    open();
988
 
    if (usearch_getOffset(NULL) != USEARCH_DONE) {
989
 
        log_err("usearch_getOffset(NULL) expected USEARCH_DONE\n");
990
 
    }
991
 
    strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL, 
992
 
                                       &status);
993
 
    /* testing out of bounds error */
994
 
    usearch_setOffset(strsrch, -1, &status);
995
 
    if (U_SUCCESS(status)) {
996
 
        log_err("Error expecting set offset error\n");
997
 
    }
998
 
    usearch_setOffset(strsrch, 128, &status);
999
 
    if (U_SUCCESS(status)) {
1000
 
        log_err("Error expecting set offset error\n");
1001
 
    }
1002
 
    while (BASIC[index].text != NULL) {
1003
 
        int         count       = 0;
1004
 
        SearchData  search      = BASIC[index ++];
1005
 
        int32_t matchindex  = search.offset[count];
1006
 
        int32_t     textlength;
1007
 
    
1008
 
        u_unescape(search.text, text, 128);
1009
 
        u_unescape(search.pattern, pattern, 32);
1010
 
        status = U_ZERO_ERROR;
1011
 
        usearch_setText(strsrch, text, -1, &status);
1012
 
        usearch_setPattern(strsrch, pattern, -1, &status);
1013
 
        while (U_SUCCESS(status) && matchindex >= 0) {
1014
 
            uint32_t matchlength = search.size[count];
1015
 
            usearch_next(strsrch, &status);
1016
 
            if (matchindex != usearch_getMatchedStart(strsrch) || 
1017
 
                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
1018
 
                char *str = toCharString(usearch_getText(strsrch, 
1019
 
                                                         &textlength));
1020
 
                log_err("Text: %s\n", str);
1021
 
                str = toCharString(usearch_getPattern(strsrch, &textlength));
1022
 
                log_err("Pattern: %s\n", str);
1023
 
                log_err("Error match found at %d %d\n", 
1024
 
                        usearch_getMatchedStart(strsrch), 
1025
 
                        usearch_getMatchedLength(strsrch));
1026
 
                return;
1027
 
            }
1028
 
            usearch_setOffset(strsrch, matchindex + matchlength, &status);
1029
 
            usearch_previous(strsrch, &status);
1030
 
            if (matchindex != usearch_getMatchedStart(strsrch) || 
1031
 
                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
1032
 
                char *str = toCharString(usearch_getText(strsrch, 
1033
 
                                                         &textlength));
1034
 
                log_err("Text: %s\n", str);
1035
 
                str = toCharString(usearch_getPattern(strsrch, &textlength));
1036
 
                log_err("Pattern: %s\n", str);
1037
 
                log_err("Error match found at %d %d\n", 
1038
 
                        usearch_getMatchedStart(strsrch), 
1039
 
                        usearch_getMatchedLength(strsrch));
1040
 
                return;
1041
 
            }
1042
 
            usearch_setOffset(strsrch, matchindex + matchlength, &status);
1043
 
            matchindex = search.offset[count + 1] == -1 ? -1 : 
1044
 
                         search.offset[count + 2];
1045
 
            if (search.offset[count + 1] != -1) {
1046
 
                usearch_setOffset(strsrch, search.offset[count + 1] + 1, 
1047
 
                                  &status);
1048
 
                if (usearch_getOffset(strsrch) != search.offset[count + 1] + 1) {
1049
 
                    log_err("Error setting offset\n");
1050
 
                    return;
1051
 
                }
1052
 
            }
1053
 
            
1054
 
            count += 2;
1055
 
        }
1056
 
        usearch_next(strsrch, &status);
1057
 
        if ((uint32_t)usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
1058
 
            char *str = toCharString(usearch_getText(strsrch, &textlength));
1059
 
            log_err("Text: %s\n", str);
1060
 
            str = toCharString(usearch_getPattern(strsrch, &textlength));
1061
 
            log_err("Pattern: %s\n", str);
1062
 
            log_err("Error match found at %d %d\n", 
1063
 
                        usearch_getMatchedStart(strsrch), 
1064
 
                        usearch_getMatchedLength(strsrch));
1065
 
            return;
1066
 
        }
1067
 
    }
1068
 
    usearch_close(strsrch);
1069
 
    close();
1070
 
}
1071
 
 
1072
 
static void TestGetSetAttribute(void) 
1073
 
{
1074
 
    UErrorCode      status    = U_ZERO_ERROR;
1075
 
    UChar           pattern[32];
1076
 
    UChar           text[128];
1077
 
    UStringSearch  *strsrch;
1078
 
          
1079
 
    open();
1080
 
    if (usearch_getAttribute(NULL, USEARCH_OVERLAP) != USEARCH_DEFAULT ||
1081
 
        usearch_getAttribute(NULL, USEARCH_CANONICAL_MATCH) != 
1082
 
                                                         USEARCH_DEFAULT) {
1083
 
        log_err(
1084
 
            "Attributes for NULL string search should be USEARCH_DEFAULT\n");
1085
 
    }
1086
 
    strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL, 
1087
 
                                       &status);
1088
 
    if (U_FAILURE(status)) {
1089
 
        log_err("Error opening search %s\n", u_errorName(status));
1090
 
        return;
1091
 
    }
1092
 
 
1093
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_DEFAULT, &status);
1094
 
    if (U_FAILURE(status) || 
1095
 
        usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
1096
 
        log_err("Error setting overlap to the default\n");
1097
 
    }
1098
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
1099
 
    if (U_FAILURE(status) || 
1100
 
        usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
1101
 
        log_err("Error setting overlap true\n");
1102
 
    }
1103
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
1104
 
    if (U_FAILURE(status) || 
1105
 
        usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
1106
 
        log_err("Error setting overlap false\n");
1107
 
    }
1108
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, 
1109
 
                         USEARCH_ATTRIBUTE_VALUE_COUNT, &status);
1110
 
    if (U_SUCCESS(status)) {
1111
 
        log_err("Error setting overlap to illegal value\n");
1112
 
    }
1113
 
    status = U_ZERO_ERROR;
1114
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_DEFAULT, 
1115
 
                         &status);
1116
 
    if (U_FAILURE(status) || 
1117
 
        usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) != 
1118
 
                                                        USEARCH_OFF) {
1119
 
        log_err("Error setting canonical match to the default\n");
1120
 
    }
1121
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1122
 
                         &status);
1123
 
    if (U_FAILURE(status) || 
1124
 
        usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) != 
1125
 
                                                         USEARCH_ON) {
1126
 
        log_err("Error setting canonical match true\n");
1127
 
    }
1128
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_OFF, 
1129
 
                         &status);
1130
 
    if (U_FAILURE(status) || 
1131
 
        usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) != 
1132
 
                                                        USEARCH_OFF) {
1133
 
        log_err("Error setting canonical match false\n");
1134
 
    }
1135
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, 
1136
 
                         USEARCH_ATTRIBUTE_VALUE_COUNT, &status);
1137
 
    if (U_SUCCESS(status)) {
1138
 
        log_err("Error setting canonical match to illegal value\n");
1139
 
    }
1140
 
    status = U_ZERO_ERROR;
1141
 
    usearch_setAttribute(strsrch, USEARCH_ATTRIBUTE_COUNT, USEARCH_DEFAULT, 
1142
 
                         &status);
1143
 
    if (U_SUCCESS(status)) {
1144
 
        log_err("Error setting illegal attribute success\n");
1145
 
    }
1146
 
 
1147
 
    usearch_close(strsrch);
1148
 
    close();
1149
 
}
1150
 
 
1151
 
static void TestGetMatch(void)
1152
 
{
1153
 
    int            count       = 0;
1154
 
    UErrorCode     status      = U_ZERO_ERROR;
1155
 
    UChar          text[128];
1156
 
    UChar          pattern[32];
1157
 
    SearchData     search      = MATCH[0];
1158
 
    int32_t    matchindex  = search.offset[count];
1159
 
    UStringSearch *strsrch;
1160
 
    int32_t        textlength;
1161
 
    UChar          matchtext[128];
1162
 
    
1163
 
    open();
1164
 
 
1165
 
    if (usearch_getMatchedStart(NULL) != USEARCH_DONE || 
1166
 
        usearch_getMatchedLength(NULL) != USEARCH_DONE) {
1167
 
        log_err(
1168
 
   "Expected start and length of NULL string search should be USEARCH_DONE\n");
1169
 
    }
1170
 
 
1171
 
    u_unescape(search.text, text, 128);
1172
 
    u_unescape(search.pattern, pattern, 32);
1173
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
1174
 
                                       NULL, &status);
1175
 
    if (U_FAILURE(status)) {
1176
 
        log_err("Error opening string search %s\n", u_errorName(status));
1177
 
        if (strsrch != NULL) {
1178
 
            usearch_close(strsrch);
1179
 
        }
1180
 
        return;
1181
 
    }
1182
 
    
1183
 
    while (U_SUCCESS(status) && matchindex >= 0) {
1184
 
        int32_t matchlength = search.size[count];
1185
 
        usearch_next(strsrch, &status);
1186
 
        if (matchindex != usearch_getMatchedStart(strsrch) || 
1187
 
            matchlength != usearch_getMatchedLength(strsrch)) {
1188
 
            char *str = toCharString(usearch_getText(strsrch, &textlength));
1189
 
            log_err("Text: %s\n", str);
1190
 
            str = toCharString(usearch_getPattern(strsrch, &textlength));
1191
 
            log_err("Pattern: %s\n", str);
1192
 
            log_err("Error match found at %d %d\n", 
1193
 
                    usearch_getMatchedStart(strsrch), 
1194
 
                    usearch_getMatchedLength(strsrch));
1195
 
            return;
1196
 
        }
1197
 
        count ++;
1198
 
        
1199
 
        status = U_ZERO_ERROR;
1200
 
        if (usearch_getMatchedText(NULL, matchtext, 128, &status) != 
1201
 
            USEARCH_DONE || U_SUCCESS(status)){
1202
 
            log_err("Error expecting errors with NULL string search\n");
1203
 
        }
1204
 
        status = U_ZERO_ERROR;
1205
 
        if (usearch_getMatchedText(strsrch, NULL, 0, &status) != 
1206
 
            (int32_t)matchlength || U_SUCCESS(status)){
1207
 
            log_err("Error pre-flighting match length\n");
1208
 
        }
1209
 
        status = U_ZERO_ERROR;
1210
 
        if (usearch_getMatchedText(strsrch, matchtext, 0, &status) != 
1211
 
            (int32_t)matchlength || U_SUCCESS(status)){
1212
 
            log_err("Error getting match text with buffer size 0\n");
1213
 
        }
1214
 
        status = U_ZERO_ERROR;
1215
 
        if (usearch_getMatchedText(strsrch, matchtext, matchlength, &status) 
1216
 
            != (int32_t)matchlength || matchtext[matchlength - 1] == 0 ||
1217
 
            U_FAILURE(status)){
1218
 
            log_err("Error getting match text with exact size\n");
1219
 
        }
1220
 
        status = U_ZERO_ERROR;
1221
 
        if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
1222
 
            (int32_t) matchlength || U_FAILURE(status) ||
1223
 
            memcmp(matchtext, 
1224
 
                   usearch_getText(strsrch, &textlength) + matchindex,
1225
 
                   matchlength * sizeof(UChar)) != 0 ||
1226
 
            matchtext[matchlength] != 0) {
1227
 
            log_err("Error getting matched text\n");
1228
 
        }
1229
 
 
1230
 
        matchindex = search.offset[count];
1231
 
    }
1232
 
    status = U_ZERO_ERROR;
1233
 
    usearch_next(strsrch, &status);
1234
 
    if (usearch_getMatchedStart(strsrch)  != USEARCH_DONE || 
1235
 
        usearch_getMatchedLength(strsrch) != 0) {
1236
 
        log_err("Error end of match not found\n");
1237
 
    }
1238
 
    status = U_ZERO_ERROR;
1239
 
    if (usearch_getMatchedText(strsrch, matchtext, 128, &status) != 
1240
 
        USEARCH_DONE) {
1241
 
        log_err("Error getting null matches\n");
1242
 
    }
1243
 
    usearch_close(strsrch);
1244
 
    close();
1245
 
}
1246
 
 
1247
 
static void TestSetMatch(void)
1248
 
{
1249
 
    int            count       = 0;
1250
 
    
1251
 
    open();
1252
 
    while (MATCH[count].text != NULL) {
1253
 
        SearchData     search = MATCH[count];
1254
 
        int            size   = 0;
1255
 
        int            index = 0;
1256
 
        UChar          text[128];
1257
 
        UChar          pattern[32];
1258
 
        UStringSearch *strsrch;
1259
 
        UErrorCode status = U_ZERO_ERROR;
1260
 
 
1261
 
        if (usearch_first(NULL, &status) != USEARCH_DONE ||
1262
 
            usearch_last(NULL, &status) != USEARCH_DONE) {
1263
 
            log_err("Error getting the first and last match of a NULL string search\n");
1264
 
        }
1265
 
        u_unescape(search.text, text, 128);
1266
 
        u_unescape(search.pattern, pattern, 32);
1267
 
        strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
1268
 
                                           NULL, &status);
1269
 
        if (U_FAILURE(status)) {
1270
 
            log_err("Error opening string search %s\n", u_errorName(status));
1271
 
            if (strsrch != NULL) {
1272
 
                usearch_close(strsrch);
1273
 
            }
1274
 
            return;
1275
 
        }
1276
 
 
1277
 
        size = 0;
1278
 
        while (search.offset[size] != -1) {
1279
 
            size ++;
1280
 
        }
1281
 
 
1282
 
        if (usearch_first(strsrch, &status) != search.offset[0] ||
1283
 
            U_FAILURE(status)) {
1284
 
            log_err("Error getting first match\n");
1285
 
        }
1286
 
        if (usearch_last(strsrch, &status) != search.offset[size -1] ||
1287
 
            U_FAILURE(status)) {
1288
 
            log_err("Error getting last match\n");
1289
 
        }
1290
 
        
1291
 
        while (index < size) {
1292
 
            if (index + 2 < size) {
1293
 
                if (usearch_following(strsrch, search.offset[index + 2] - 1,
1294
 
                                      &status) != search.offset[index + 2] ||
1295
 
                    U_FAILURE(status)) {
1296
 
                    log_err("Error getting following match at index %d\n", 
1297
 
                            search.offset[index + 2] - 1);
1298
 
                }
1299
 
            }
1300
 
            if (index + 1 < size) {
1301
 
                if (usearch_preceding(strsrch, search.offset[index + 1] + 
1302
 
                                               search.size[index + 1] + 1, 
1303
 
                                      &status) != search.offset[index + 1] ||
1304
 
                    U_FAILURE(status)) {
1305
 
                    log_err("Error getting preceeding match at index %d\n", 
1306
 
                            search.offset[index + 1] + 1);
1307
 
                }
1308
 
            }
1309
 
            index += 2;
1310
 
        }
1311
 
        status = U_ZERO_ERROR;
1312
 
        if (usearch_following(strsrch, u_strlen(text), &status) != 
1313
 
            USEARCH_DONE) {
1314
 
            log_err("Error expecting out of bounds match\n");
1315
 
        }
1316
 
        if (usearch_preceding(strsrch, 0, &status) != USEARCH_DONE) {
1317
 
            log_err("Error expecting out of bounds match\n");
1318
 
        }
1319
 
        count ++;
1320
 
        usearch_close(strsrch);
1321
 
    }
1322
 
    close();
1323
 
}
1324
 
 
1325
 
static void TestReset(void)
1326
 
{
1327
 
    UErrorCode     status    = U_ZERO_ERROR;
1328
 
    UChar          text[]    = {0x66, 0x69, 0x73, 0x68, 0x20, 
1329
 
                                0x66, 0x69, 0x73, 0x68};
1330
 
    UChar          pattern[] = {0x73};
1331
 
    UStringSearch *strsrch;
1332
 
    
1333
 
    open();
1334
 
    strsrch = usearch_openFromCollator(pattern, 1, text, 9, 
1335
 
                                                      EN_US_, NULL, &status);
1336
 
    if (U_FAILURE(status)) {
1337
 
        log_err("Error opening string search %s\n", u_errorName(status));
1338
 
        if (strsrch != NULL) {
1339
 
            usearch_close(strsrch);
1340
 
        }
1341
 
        return;
1342
 
    }
1343
 
    usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
1344
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1345
 
                         &status);
1346
 
    usearch_setOffset(strsrch, 9, &status);
1347
 
    if (U_FAILURE(status)) {
1348
 
        log_err("Error setting attributes and offsets\n");
1349
 
    }
1350
 
    else {
1351
 
        usearch_reset(strsrch);
1352
 
        if (usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF ||
1353
 
            usearch_getAttribute(strsrch, USEARCH_CANONICAL_MATCH) != 
1354
 
                                 USEARCH_OFF ||
1355
 
            usearch_getOffset(strsrch) != 0 ||
1356
 
            usearch_getMatchedLength(strsrch) != 0 ||
1357
 
            usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
1358
 
            log_err("Error resetting string search\n");
1359
 
        }
1360
 
        usearch_previous(strsrch, &status);
1361
 
        if (usearch_getMatchedStart(strsrch) != 7 ||
1362
 
            usearch_getMatchedLength(strsrch) != 1) {
1363
 
            log_err("Error resetting string search\n");
1364
 
        }
1365
 
    }
1366
 
    usearch_close(strsrch);
1367
 
    close();
1368
 
}
1369
 
 
1370
 
static void TestSupplementary(void)
1371
 
{
1372
 
    int count = 0;
1373
 
    open();
1374
 
    while (SUPPLEMENTARY[count].text != NULL) {
1375
 
        if (!assertEqual(SUPPLEMENTARY[count])) {
1376
 
            log_err("Error at test number %d\n", count);
1377
 
        }
1378
 
        count ++;
1379
 
    }
1380
 
    close();
1381
 
}
1382
 
 
1383
 
static void TestContraction(void) 
1384
 
{
1385
 
    UChar          rules[128];
1386
 
    UChar          pattern[128];
1387
 
    UChar          text[128];
1388
 
    UCollator     *collator;
1389
 
    UErrorCode     status = U_ZERO_ERROR;
1390
 
    int            count = 0;
1391
 
    UStringSearch *strsrch;
1392
 
 
1393
 
    u_unescape(CONTRACTIONRULE, rules, 128);
1394
 
    collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON, 
1395
 
                              UCOL_TERTIARY, NULL, &status); 
1396
 
    if (U_FAILURE(status)) {
1397
 
        log_err("Error opening collator %s\n", u_errorName(status));
1398
 
    }
1399
 
    strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL, 
1400
 
                                       &status);
1401
 
    if (U_FAILURE(status)) {
1402
 
        log_err("Error opening string search %s\n", u_errorName(status));
1403
 
    }   
1404
 
    
1405
 
    while (CONTRACTION[count].text != NULL) {
1406
 
        u_unescape(CONTRACTION[count].text, text, 128);
1407
 
        u_unescape(CONTRACTION[count].pattern, pattern, 128);
1408
 
        usearch_setText(strsrch, text, -1, &status);
1409
 
        usearch_setPattern(strsrch, pattern, -1, &status);
1410
 
        if (!assertEqualWithUStringSearch(strsrch, CONTRACTION[count])) {
1411
 
            log_err("Error at test number %d\n", count);
1412
 
        }
1413
 
        count ++;
1414
 
    }
1415
 
    usearch_close(strsrch);
1416
 
    ucol_close(collator);
1417
 
}
1418
 
 
1419
 
static void TestIgnorable(void) 
1420
 
{
1421
 
    UChar          rules[128];
1422
 
    UChar          pattern[128];
1423
 
    UChar          text[128];
1424
 
    UCollator     *collator;
1425
 
    UErrorCode     status = U_ZERO_ERROR;
1426
 
    UStringSearch *strsrch;
1427
 
    uint32_t       count = 0;
1428
 
 
1429
 
    u_unescape(IGNORABLERULE, rules, 128);
1430
 
    collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON, 
1431
 
                              IGNORABLE[count].strength, NULL, &status); 
1432
 
    if (U_FAILURE(status)) {
1433
 
        log_err("Error opening collator %s\n", u_errorName(status));
1434
 
    }
1435
 
    strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL, 
1436
 
                                       &status);
1437
 
    if (U_FAILURE(status)) {
1438
 
        log_err("Error opening string search %s\n", u_errorName(status));
1439
 
    }   
1440
 
    
1441
 
    while (IGNORABLE[count].text != NULL) {
1442
 
        u_unescape(IGNORABLE[count].text, text, 128);
1443
 
        u_unescape(IGNORABLE[count].pattern, pattern, 128);
1444
 
        usearch_setText(strsrch, text, -1, &status);
1445
 
        usearch_setPattern(strsrch, pattern, -1, &status);
1446
 
        if (!assertEqualWithUStringSearch(strsrch, IGNORABLE[count])) {
1447
 
            log_err("Error at test number %d\n", count);
1448
 
        }
1449
 
        count ++;
1450
 
    }
1451
 
    usearch_close(strsrch);
1452
 
    ucol_close(collator);
1453
 
}
1454
 
 
1455
 
static void TestCanonical(void)
1456
 
{
1457
 
    int count = 0;
1458
 
    open();
1459
 
    while (BASICCANONICAL[count].text != NULL) {
1460
 
        if (!assertCanonicalEqual(BASICCANONICAL[count])) {
1461
 
            log_err("Error at test number %d\n", count);
1462
 
        }
1463
 
        count ++;
1464
 
    }
1465
 
    close();
1466
 
}
1467
 
 
1468
 
static void TestNormCanonical(void) 
1469
 
{
1470
 
    int count = 0;
1471
 
    UErrorCode status = U_ZERO_ERROR;
1472
 
    open();
1473
 
    ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
1474
 
    count = 0;
1475
 
    while (NORMCANONICAL[count].text != NULL) {
1476
 
        if (!assertCanonicalEqual(NORMCANONICAL[count])) {
1477
 
            log_err("Error at test number %d\n", count);
1478
 
        }
1479
 
        count ++;
1480
 
    }
1481
 
    ucol_setAttribute(EN_US_, UCOL_NORMALIZATION_MODE, UCOL_OFF, &status);
1482
 
    close();
1483
 
}
1484
 
 
1485
 
static void TestStrengthCanonical(void) 
1486
 
{
1487
 
    int count = 0;
1488
 
    open();
1489
 
    while (STRENGTHCANONICAL[count].text != NULL) {
1490
 
        if (!assertCanonicalEqual(STRENGTHCANONICAL[count])) {
1491
 
            log_err("Error at test number %d\n", count);
1492
 
        }
1493
 
        count ++;
1494
 
    }
1495
 
    close();
1496
 
}
1497
 
 
1498
 
static void TestBreakIteratorCanonical(void) {
1499
 
    UErrorCode      status      = U_ZERO_ERROR;
1500
 
    int             count = 0;
1501
 
 
1502
 
    open();
1503
 
    while (count < 4) {
1504
 
        /* 0-3 test are fixed */
1505
 
              UChar           pattern[32];
1506
 
              UChar           text[128];
1507
 
        const SearchData     *search   = &(BREAKITERATORCANONICAL[count]);     
1508
 
              UCollator      *collator = getCollator(search->collator);
1509
 
              UBreakIterator *breaker  = getBreakIterator(search->breaker);
1510
 
              UStringSearch  *strsrch; 
1511
 
    
1512
 
        u_unescape(search->text, text, 128);
1513
 
        u_unescape(search->pattern, pattern, 32);
1514
 
        ucol_setStrength(collator, search->strength);
1515
 
        
1516
 
        strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
1517
 
                                           breaker, &status);
1518
 
        usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1519
 
                             &status);
1520
 
        if (U_FAILURE(status) || 
1521
 
            usearch_getBreakIterator(strsrch) != breaker) {
1522
 
            log_err("Error setting break iterator\n");
1523
 
            if (strsrch != NULL) {
1524
 
                usearch_close(strsrch);
1525
 
            }
1526
 
        }
1527
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
1528
 
            ucol_setStrength(collator, UCOL_TERTIARY);
1529
 
            usearch_close(strsrch);
1530
 
            goto ENDTESTBREAKITERATOR;
1531
 
        }
1532
 
        search   = &(BREAKITERATOREXACT[count + 1]);
1533
 
        breaker  = getBreakIterator(search->breaker);
1534
 
        usearch_setBreakIterator(strsrch, breaker, &status);
1535
 
        if (U_FAILURE(status) || 
1536
 
            usearch_getBreakIterator(strsrch) != breaker) {
1537
 
            log_err("Error setting break iterator\n");
1538
 
            usearch_close(strsrch);
1539
 
            goto ENDTESTBREAKITERATOR;
1540
 
        }
1541
 
        usearch_reset(strsrch);
1542
 
        usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1543
 
                             &status);
1544
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
1545
 
             log_err("Error at test number %d\n", count);
1546
 
             goto ENDTESTBREAKITERATOR;
1547
 
        }
1548
 
        usearch_close(strsrch);
1549
 
        count += 2;
1550
 
    }
1551
 
    count = 0;
1552
 
    while (BREAKITERATORCANONICAL[count].text != NULL) {
1553
 
         if (!assertEqual(BREAKITERATORCANONICAL[count])) {
1554
 
             log_err("Error at test number %d\n", count);
1555
 
             goto ENDTESTBREAKITERATOR;
1556
 
         }
1557
 
         count ++;
1558
 
    }
1559
 
    
1560
 
ENDTESTBREAKITERATOR:
1561
 
    close();
1562
 
}
1563
 
 
1564
 
static void TestVariableCanonical(void) 
1565
 
{
1566
 
    int count = 0;
1567
 
    UErrorCode status = U_ZERO_ERROR;
1568
 
    open();
1569
 
    ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
1570
 
    if (U_FAILURE(status)) {
1571
 
        log_err("Error setting collation alternate attribute %s\n", 
1572
 
            u_errorName(status));
1573
 
    }
1574
 
    while (VARIABLE[count].text != NULL) {
1575
 
        log_verbose("variable %d\n", count);
1576
 
        if (!assertCanonicalEqual(VARIABLE[count])) {
1577
 
            log_err("Error at test number %d\n", count);
1578
 
        }
1579
 
        count ++;
1580
 
    }
1581
 
    ucol_setAttribute(EN_US_, UCOL_ALTERNATE_HANDLING, 
1582
 
                      UCOL_NON_IGNORABLE, &status);
1583
 
    close();
1584
 
}
1585
 
 
1586
 
static void TestOverlapCanonical(void)
1587
 
{
1588
 
    int count = 0;
1589
 
    open();
1590
 
    while (OVERLAPCANONICAL[count].text != NULL) {
1591
 
        if (!assertEqualWithAttribute(OVERLAPCANONICAL[count], USEARCH_ON, 
1592
 
                                      USEARCH_ON)) {
1593
 
            log_err("Error at overlap test number %d\n", count);
1594
 
        }
1595
 
        count ++;
1596
 
    }    
1597
 
    count = 0;
1598
 
    while (NONOVERLAP[count].text != NULL) {
1599
 
        if (!assertCanonicalEqual(NONOVERLAPCANONICAL[count])) {
1600
 
            log_err("Error at non overlap test number %d\n", count);
1601
 
        }
1602
 
        count ++;
1603
 
    }
1604
 
 
1605
 
    count = 0;
1606
 
    while (count < 1) {
1607
 
              UChar           pattern[32];
1608
 
              UChar           text[128];
1609
 
        const SearchData     *search   = &(OVERLAPCANONICAL[count]);     
1610
 
              UCollator      *collator = getCollator(search->collator);
1611
 
              UStringSearch  *strsrch; 
1612
 
              UErrorCode      status   = U_ZERO_ERROR;
1613
 
    
1614
 
        u_unescape(search->text, text, 128);
1615
 
        u_unescape(search->pattern, pattern, 32);
1616
 
        strsrch = usearch_openFromCollator(pattern, -1, text, -1, collator, 
1617
 
                                           NULL, &status);
1618
 
        usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1619
 
                             &status);
1620
 
        usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_ON, &status);
1621
 
        if (U_FAILURE(status) ||
1622
 
            usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_ON) {
1623
 
            log_err("Error setting overlap option\n");
1624
 
        }
1625
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
1626
 
            usearch_close(strsrch);
1627
 
            return;
1628
 
        }
1629
 
        search   = &(NONOVERLAPCANONICAL[count]);
1630
 
        usearch_setAttribute(strsrch, USEARCH_OVERLAP, USEARCH_OFF, &status);
1631
 
        if (U_FAILURE(status) ||
1632
 
            usearch_getAttribute(strsrch, USEARCH_OVERLAP) != USEARCH_OFF) {
1633
 
            log_err("Error setting overlap option\n");
1634
 
        }
1635
 
        usearch_reset(strsrch);
1636
 
        if (!assertEqualWithUStringSearch(strsrch, *search)) {
1637
 
            usearch_close(strsrch);
1638
 
            log_err("Error at test number %d\n", count);
1639
 
         }
1640
 
 
1641
 
        count ++;
1642
 
        usearch_close(strsrch);
1643
 
    }
1644
 
    close();
1645
 
}
1646
 
 
1647
 
static void TestCollatorCanonical(void) 
1648
 
{
1649
 
    /* test collator that thinks "o" and "p" are the same thing */
1650
 
          UChar          rules[32];
1651
 
          UCollator     *tailored = NULL; 
1652
 
          UErrorCode     status = U_ZERO_ERROR;
1653
 
          UChar          pattern[32];
1654
 
          UChar          text[128];
1655
 
          UStringSearch *strsrch; 
1656
 
          
1657
 
    open();
1658
 
    u_unescape(COLLATORCANONICAL[0].text, text, 128);
1659
 
    u_unescape(COLLATORCANONICAL[0].pattern, pattern, 32);
1660
 
 
1661
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
1662
 
                                       NULL, &status);
1663
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1664
 
                         &status);
1665
 
    if (U_FAILURE(status)) {
1666
 
        log_err("Error opening string search %s\n", u_errorName(status));
1667
 
    }
1668
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[0])) {
1669
 
        goto ENDTESTCOLLATOR;
1670
 
    }
1671
 
    
1672
 
    u_unescape(TESTCOLLATORRULE, rules, 32);
1673
 
    tailored = ucol_openRules(rules, -1, UCOL_ON, 
1674
 
                              COLLATORCANONICAL[1].strength, NULL, &status);
1675
 
    if (U_FAILURE(status)) {
1676
 
        log_err("Error opening rule based collator %s\n", u_errorName(status));
1677
 
    }
1678
 
 
1679
 
    usearch_setCollator(strsrch, tailored, &status);
1680
 
    if (U_FAILURE(status) || usearch_getCollator(strsrch) != tailored) {
1681
 
        log_err("Error setting rule based collator\n");
1682
 
    }
1683
 
    usearch_reset(strsrch);
1684
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1685
 
                         &status);
1686
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[1])) {
1687
 
        goto ENDTESTCOLLATOR;
1688
 
    }
1689
 
        
1690
 
    usearch_setCollator(strsrch, EN_US_, &status);
1691
 
    usearch_reset(strsrch);
1692
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1693
 
                         &status);
1694
 
    if (U_FAILURE(status) || usearch_getCollator(strsrch) != EN_US_) {
1695
 
        log_err("Error setting rule based collator\n");
1696
 
    }
1697
 
    if (!assertEqualWithUStringSearch(strsrch, COLLATORCANONICAL[0])) {
1698
 
        goto ENDTESTCOLLATOR;
1699
 
    }
1700
 
    
1701
 
ENDTESTCOLLATOR:
1702
 
    usearch_close(strsrch);
1703
 
    if (tailored != NULL) {
1704
 
        ucol_close(tailored);
1705
 
    }
1706
 
    close();
1707
 
}
1708
 
 
1709
 
static void TestPatternCanonical(void)
1710
 
{
1711
 
          UStringSearch *strsrch; 
1712
 
          UChar          pattern[32];
1713
 
          UChar          text[128];
1714
 
    const UChar         *temp;
1715
 
          int32_t        templength;
1716
 
          UErrorCode     status = U_ZERO_ERROR;
1717
 
 
1718
 
    open();
1719
 
    u_unescape(PATTERNCANONICAL[0].text, text, 128);
1720
 
    u_unescape(PATTERNCANONICAL[0].pattern, pattern, 32);
1721
 
 
1722
 
    ucol_setStrength(EN_US_, PATTERNCANONICAL[0].strength);
1723
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
1724
 
                                       NULL, &status);
1725
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1726
 
                         &status);
1727
 
    if (U_FAILURE(status)) {
1728
 
        log_err("Error opening string search %s\n", u_errorName(status));
1729
 
        goto ENDTESTPATTERN;
1730
 
    }
1731
 
    temp = usearch_getPattern(strsrch, &templength);
1732
 
    if (u_strcmp(pattern, temp) != 0) {
1733
 
        log_err("Error setting pattern\n");
1734
 
    }
1735
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[0])) {
1736
 
        goto ENDTESTPATTERN;
1737
 
    }
1738
 
 
1739
 
    u_unescape(PATTERNCANONICAL[1].pattern, pattern, 32);
1740
 
    usearch_setPattern(strsrch, pattern, -1, &status);
1741
 
    temp = usearch_getPattern(strsrch, &templength);
1742
 
    if (u_strcmp(pattern, temp) != 0) {
1743
 
        log_err("Error setting pattern\n");
1744
 
        goto ENDTESTPATTERN;
1745
 
    }
1746
 
    usearch_reset(strsrch);
1747
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1748
 
                         &status);
1749
 
    if (U_FAILURE(status)) {
1750
 
        log_err("Error setting pattern %s\n", u_errorName(status));
1751
 
    }
1752
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[1])) {
1753
 
        goto ENDTESTPATTERN;
1754
 
    }
1755
 
 
1756
 
    u_unescape(PATTERNCANONICAL[0].pattern, pattern, 32);
1757
 
    usearch_setPattern(strsrch, pattern, -1, &status);
1758
 
    temp = usearch_getPattern(strsrch, &templength);
1759
 
    if (u_strcmp(pattern, temp) != 0) {
1760
 
        log_err("Error setting pattern\n");
1761
 
        goto ENDTESTPATTERN;
1762
 
    }
1763
 
    usearch_reset(strsrch);
1764
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1765
 
                         &status);
1766
 
    if (U_FAILURE(status)) {
1767
 
        log_err("Error setting pattern %s\n", u_errorName(status));
1768
 
    }
1769
 
    if (!assertEqualWithUStringSearch(strsrch, PATTERNCANONICAL[0])) {
1770
 
        goto ENDTESTPATTERN;
1771
 
    }
1772
 
ENDTESTPATTERN:
1773
 
    ucol_setStrength(EN_US_, UCOL_TERTIARY);
1774
 
    if (strsrch != NULL) {
1775
 
        usearch_close(strsrch);
1776
 
    }
1777
 
    close();
1778
 
}
1779
 
 
1780
 
static void TestTextCanonical(void) 
1781
 
{
1782
 
          UStringSearch *strsrch; 
1783
 
          UChar          pattern[32];
1784
 
          UChar          text[128];
1785
 
    const UChar         *temp;
1786
 
          int32_t        templength;
1787
 
          UErrorCode     status = U_ZERO_ERROR;
1788
 
 
1789
 
    u_unescape(TEXTCANONICAL[0].text, text, 128);
1790
 
    u_unescape(TEXTCANONICAL[0].pattern, pattern, 32);
1791
 
 
1792
 
    open();
1793
 
    strsrch = usearch_openFromCollator(pattern, -1, text, -1, EN_US_, 
1794
 
                                       NULL, &status);
1795
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1796
 
                         &status);
1797
 
 
1798
 
    if (U_FAILURE(status)) {
1799
 
        log_err("Error opening string search %s\n", u_errorName(status));
1800
 
        goto ENDTESTPATTERN;
1801
 
    }
1802
 
    temp = usearch_getText(strsrch, &templength);
1803
 
    if (u_strcmp(text, temp) != 0) {
1804
 
        log_err("Error setting text\n");
1805
 
    }
1806
 
    if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[0])) {
1807
 
        goto ENDTESTPATTERN;
1808
 
    }
1809
 
 
1810
 
    u_unescape(TEXTCANONICAL[1].text, text, 32);
1811
 
    usearch_setText(strsrch, text, -1, &status);
1812
 
    temp = usearch_getText(strsrch, &templength);
1813
 
    if (u_strcmp(text, temp) != 0) {
1814
 
        log_err("Error setting text\n");
1815
 
        goto ENDTESTPATTERN;
1816
 
    }
1817
 
    if (U_FAILURE(status)) {
1818
 
        log_err("Error setting text %s\n", u_errorName(status));
1819
 
    }
1820
 
    if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[1])) {
1821
 
        goto ENDTESTPATTERN;
1822
 
    }
1823
 
 
1824
 
    u_unescape(TEXTCANONICAL[0].text, text, 32);
1825
 
    usearch_setText(strsrch, text, -1, &status);
1826
 
    temp = usearch_getText(strsrch, &templength);
1827
 
    if (u_strcmp(text, temp) != 0) {
1828
 
        log_err("Error setting text\n");
1829
 
        goto ENDTESTPATTERN;
1830
 
    }
1831
 
    if (U_FAILURE(status)) {
1832
 
        log_err("Error setting pattern %s\n", u_errorName(status));
1833
 
    }
1834
 
    if (!assertEqualWithUStringSearch(strsrch, TEXTCANONICAL[0])) {
1835
 
        goto ENDTESTPATTERN;
1836
 
    }
1837
 
ENDTESTPATTERN:
1838
 
    if (strsrch != NULL) {
1839
 
        usearch_close(strsrch);
1840
 
    }
1841
 
    close();
1842
 
}
1843
 
 
1844
 
static void TestCompositeBoundariesCanonical(void) 
1845
 
{
1846
 
    int count = 0;
1847
 
    open();
1848
 
    while (COMPOSITEBOUNDARIESCANONICAL[count].text != NULL) { 
1849
 
        log_verbose("composite %d\n", count);
1850
 
        if (!assertCanonicalEqual(COMPOSITEBOUNDARIESCANONICAL[count])) {
1851
 
            log_err("Error at test number %d\n", count);
1852
 
        }
1853
 
        count ++;
1854
 
    } 
1855
 
    close();
1856
 
}
1857
 
 
1858
 
static void TestGetSetOffsetCanonical(void)
1859
 
{
1860
 
    int            index   = 0;
1861
 
    UChar          pattern[32];
1862
 
    UChar          text[128];
1863
 
    UErrorCode     status  = U_ZERO_ERROR;
1864
 
    UStringSearch *strsrch;
1865
 
 
1866
 
    open();
1867
 
    strsrch = usearch_openFromCollator(pattern, 16, text, 32, EN_US_, NULL, 
1868
 
                                       &status);
1869
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1870
 
                         &status);
1871
 
    /* testing out of bounds error */
1872
 
    usearch_setOffset(strsrch, -1, &status);
1873
 
    if (U_SUCCESS(status)) {
1874
 
        log_err("Error expecting set offset error\n");
1875
 
    }
1876
 
    usearch_setOffset(strsrch, 128, &status);
1877
 
    if (U_SUCCESS(status)) {
1878
 
        log_err("Error expecting set offset error\n");
1879
 
    }
1880
 
    while (BASICCANONICAL[index].text != NULL) {
1881
 
        int         count       = 0;
1882
 
        SearchData  search      = BASICCANONICAL[index ++];
1883
 
        int32_t matchindex  = search.offset[count];
1884
 
        int32_t     textlength;
1885
 
 
1886
 
        if (BASICCANONICAL[index].text == NULL) {
1887
 
            /* skip the last one */
1888
 
            break;
1889
 
        }
1890
 
        
1891
 
        u_unescape(search.text, text, 128);
1892
 
        u_unescape(search.pattern, pattern, 32);
1893
 
        status = U_ZERO_ERROR;
1894
 
        usearch_setText(strsrch, text, -1, &status);
1895
 
        usearch_setPattern(strsrch, pattern, -1, &status);
1896
 
        while (U_SUCCESS(status) && matchindex >= 0) {
1897
 
            uint32_t matchlength = search.size[count];
1898
 
            usearch_next(strsrch, &status);
1899
 
            if (matchindex != usearch_getMatchedStart(strsrch) || 
1900
 
                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
1901
 
                char *str = toCharString(usearch_getText(strsrch, 
1902
 
                                                         &textlength));
1903
 
                log_err("Text: %s\n", str);
1904
 
                str = toCharString(usearch_getPattern(strsrch, &textlength));
1905
 
                log_err("Pattern: %s\n", str);
1906
 
                log_err("Error match found at %d %d\n", 
1907
 
                        usearch_getMatchedStart(strsrch), 
1908
 
                        usearch_getMatchedLength(strsrch));
1909
 
                return;
1910
 
            }
1911
 
            matchindex = search.offset[count + 1] == -1 ? -1 : 
1912
 
                         search.offset[count + 2];
1913
 
            if (search.offset[count + 1] != -1) {
1914
 
                usearch_setOffset(strsrch, search.offset[count + 1] + 1, 
1915
 
                                  &status);
1916
 
                if (usearch_getOffset(strsrch) != search.offset[count + 1] + 1) {
1917
 
                    log_err("Error setting offset\n");
1918
 
                    return;
1919
 
                }
1920
 
            }
1921
 
            
1922
 
            count += 2;
1923
 
        }
1924
 
        usearch_next(strsrch, &status);
1925
 
        if ((uint32_t)usearch_getMatchedStart(strsrch) != USEARCH_DONE) {
1926
 
            char *str = toCharString(usearch_getText(strsrch, &textlength));
1927
 
            log_err("Text: %s\n", str);
1928
 
            str = toCharString(usearch_getPattern(strsrch, &textlength));
1929
 
            log_err("Pattern: %s\n", str);
1930
 
            log_err("Error match found at %d %d\n", 
1931
 
                        usearch_getMatchedStart(strsrch), 
1932
 
                        usearch_getMatchedLength(strsrch));
1933
 
            return;
1934
 
        }
1935
 
    }
1936
 
    usearch_close(strsrch);
1937
 
    close();
1938
 
}
1939
 
 
1940
 
static void TestSupplementaryCanonical(void)
1941
 
{
1942
 
    int count = 0;
1943
 
    open();
1944
 
    while (SUPPLEMENTARYCANONICAL[count].text != NULL) {
1945
 
        if (!assertCanonicalEqual(SUPPLEMENTARYCANONICAL[count])) {
1946
 
            log_err("Error at test number %d\n", count);
1947
 
        }
1948
 
        count ++;
1949
 
    }
1950
 
    close();
1951
 
}
1952
 
 
1953
 
static void TestContractionCanonical(void) 
1954
 
{
1955
 
    UChar          rules[128];
1956
 
    UChar          pattern[128];
1957
 
    UChar          text[128];
1958
 
    UCollator     *collator;
1959
 
    UErrorCode     status = U_ZERO_ERROR;
1960
 
    int            count = 0;
1961
 
    UStringSearch *strsrch;
1962
 
 
1963
 
    u_unescape(CONTRACTIONRULE, rules, 128);
1964
 
    collator = ucol_openRules(rules, u_strlen(rules), UCOL_ON,
1965
 
                              UCOL_TERTIARY, NULL, &status); 
1966
 
    if (U_FAILURE(status)) {
1967
 
        log_err("Error opening collator %s\n", u_errorName(status));
1968
 
    }
1969
 
    strsrch = usearch_openFromCollator(pattern, 1, text, 1, collator, NULL, 
1970
 
                                       &status);
1971
 
    usearch_setAttribute(strsrch, USEARCH_CANONICAL_MATCH, USEARCH_ON, 
1972
 
                         &status);
1973
 
    if (U_FAILURE(status)) {
1974
 
        log_err("Error opening string search %s\n", u_errorName(status));
1975
 
    }   
1976
 
        
1977
 
    while (CONTRACTIONCANONICAL[count].text != NULL) {
1978
 
        u_unescape(CONTRACTIONCANONICAL[count].text, text, 128);
1979
 
        u_unescape(CONTRACTIONCANONICAL[count].pattern, pattern, 128);
1980
 
        usearch_setText(strsrch, text, -1, &status);
1981
 
        usearch_setPattern(strsrch, pattern, -1, &status);
1982
 
        if (!assertEqualWithUStringSearch(strsrch, 
1983
 
                                              CONTRACTIONCANONICAL[count])) {
1984
 
            log_err("Error at test number %d\n", count);
1985
 
        }
1986
 
        count ++;
1987
 
    }
1988
 
    usearch_close(strsrch);
1989
 
    ucol_close(collator);
1990
 
}
1991
 
 
1992
 
void addSearchTest(TestNode** root)
1993
 
{
1994
 
    addTest(root, &TestStart, "tscoll/usrchtst/TestStart");
1995
 
    addTest(root, &TestOpenClose, "tscoll/usrchtst/TestOpenClose");
1996
 
    addTest(root, &TestInitialization, "tscoll/usrchtst/TestInitialization");
1997
 
    addTest(root, &TestBasic, "tscoll/usrchtst/TestBasic");
1998
 
    addTest(root, &TestNormExact, "tscoll/usrchtst/TestNormExact");
1999
 
    addTest(root, &TestStrength, "tscoll/usrchtst/TestStrength");
2000
 
    addTest(root, &TestBreakIterator, "tscoll/usrchtst/TestBreakIterator");
2001
 
    addTest(root, &TestVariable, "tscoll/usrchtst/TestVariable");
2002
 
    addTest(root, &TestOverlap, "tscoll/usrchtst/TestOverlap");
2003
 
    addTest(root, &TestCollator, "tscoll/usrchtst/TestCollator");
2004
 
    addTest(root, &TestPattern, "tscoll/usrchtst/TestPattern");
2005
 
    addTest(root, &TestText, "tscoll/usrchtst/TestText"); 
2006
 
    addTest(root, &TestCompositeBoundaries, 
2007
 
                                  "tscoll/usrchtst/TestCompositeBoundaries");
2008
 
    addTest(root, &TestGetSetOffset, "tscoll/usrchtst/TestGetSetOffset");
2009
 
    addTest(root, &TestGetSetAttribute, 
2010
 
                                      "tscoll/usrchtst/TestGetSetAttribute");
2011
 
    addTest(root, &TestGetMatch, "tscoll/usrchtst/TestGetMatch");
2012
 
    addTest(root, &TestSetMatch, "tscoll/usrchtst/TestSetMatch");
2013
 
    addTest(root, &TestReset, "tscoll/usrchtst/TestReset");
2014
 
    addTest(root, &TestSupplementary, "tscoll/usrchtst/TestSupplementary");
2015
 
    addTest(root, &TestContraction, "tscoll/usrchtst/TestContraction");
2016
 
    addTest(root, &TestIgnorable, "tscoll/usrchtst/TestIgnorable");
2017
 
    addTest(root, &TestCanonical, "tscoll/usrchtst/TestCanonical");
2018
 
    addTest(root, &TestNormCanonical, "tscoll/usrchtst/TestNormCanonical");
2019
 
    addTest(root, &TestStrengthCanonical, 
2020
 
                                    "tscoll/usrchtst/TestStrengthCanonical");
2021
 
    addTest(root, &TestBreakIteratorCanonical, 
2022
 
                               "tscoll/usrchtst/TestBreakIteratorCanonical");
2023
 
    addTest(root, &TestVariableCanonical, 
2024
 
                                    "tscoll/usrchtst/TestVariableCanonical");
2025
 
    addTest(root, &TestOverlapCanonical, 
2026
 
                                     "tscoll/usrchtst/TestOverlapCanonical");
2027
 
    addTest(root, &TestCollatorCanonical, 
2028
 
                                    "tscoll/usrchtst/TestCollatorCanonical");
2029
 
    addTest(root, &TestPatternCanonical, 
2030
 
                                     "tscoll/usrchtst/TestPatternCanonical");
2031
 
    addTest(root, &TestTextCanonical, "tscoll/usrchtst/TestTextCanonical"); 
2032
 
    addTest(root, &TestCompositeBoundariesCanonical, 
2033
 
                         "tscoll/usrchtst/TestCompositeBoundariesCanonical");
2034
 
    addTest(root, &TestGetSetOffsetCanonical, 
2035
 
                                "tscoll/usrchtst/TestGetSetOffsetCanonical");
2036
 
    addTest(root, &TestSupplementaryCanonical, 
2037
 
                               "tscoll/usrchtst/TestSupplementaryCanonical");
2038
 
    addTest(root, &TestContractionCanonical, 
2039
 
                                 "tscoll/usrchtst/TestContractionCanonical");
2040
 
    addTest(root, &TestEnd, "tscoll/usrchtst/TestEnd");
2041
 
}
2042