1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 2004-2010, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6 /********************************************************************************
7 *
8 * File reapits.c
9 *
10 *********************************************************************************/
11 /*C API TEST FOR Regular Expressions */
12 /**
13 * This is an API test for ICU regular expressions in C. It doesn't test very many cases, and doesn't
14 * try to test the full functionality. It just calls each function and verifies that it
15 * works on a basic level.
16 *
17 * More complete testing of regular expression functionality is done with the C++ tests.
18 **/
19
20 #include "unicode/utypes.h"
21
22 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include "unicode/uloc.h"
27 #include "unicode/uregex.h"
28 #include "unicode/ustring.h"
29 #include "unicode/utext.h"
30 #include "cintltst.h"
31
32 #define TEST_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
33 log_data_err("Failure at file %s, line %d, error = %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));}}
34
35 #define TEST_ASSERT(expr) {if ((expr)==FALSE) { \
36 log_data_err("Test Failure at file %s, line %d (Are you missing data?)\n", __FILE__, __LINE__);}}
37
38 /*
39 * TEST_SETUP and TEST_TEARDOWN
40 * macros to handle the boilerplate around setting up regex test cases.
41 * parameteres to setup:
42 * pattern: The regex pattern, a (char *) null terminated C string.
43 * testString: The string data, also a (char *) C string.
44 * flags: Regex flags to set when compiling the pattern
45 *
46 * Put arbitrary test code between SETUP and TEARDOWN.
47 * 're" is the compiled, ready-to-go regular expression.
48 */
49 #define TEST_SETUP(pattern, testString, flags) { \
50 UChar *srcString = NULL; \
51 status = U_ZERO_ERROR; \
52 re = uregex_openC(pattern, flags, NULL, &status); \
53 TEST_ASSERT_SUCCESS(status); \
54 srcString = (UChar *)malloc((strlen(testString)+2)*sizeof(UChar)); \
55 u_uastrncpy(srcString, testString, strlen(testString)+1); \
56 uregex_setText(re, srcString, -1, &status); \
57 TEST_ASSERT_SUCCESS(status); \
58 if (U_SUCCESS(status)) {
59
60 #define TEST_TEARDOWN \
61 } \
62 TEST_ASSERT_SUCCESS(status); \
63 uregex_close(re); \
64 free(srcString); \
65 }
66
67
68 /**
69 * @param expected utf-8 array of bytes to be expected
70 */
test_assert_string(const char * expected,const UChar * actual,UBool nulTerm,const char * file,int line)71 static void test_assert_string(const char *expected, const UChar *actual, UBool nulTerm, const char *file, int line) {
72 char buf_inside_macro[120];
73 int32_t len = (int32_t)strlen(expected);
74 UBool success;
75 if (nulTerm) {
76 u_austrncpy(buf_inside_macro, (actual), len+1);
77 buf_inside_macro[len+2] = 0;
78 success = (strcmp((expected), buf_inside_macro) == 0);
79 } else {
80 u_austrncpy(buf_inside_macro, (actual), len);
81 buf_inside_macro[len+1] = 0;
82 success = (strncmp((expected), buf_inside_macro, len) == 0);
83 }
84 if (success == FALSE) {
85 log_err("Failure at file %s, line %d, expected \"%s\", got \"%s\"\n",
86 file, line, (expected), buf_inside_macro);
87 }
88 }
89
90 #define TEST_ASSERT_STRING(expected, actual, nulTerm) test_assert_string(expected, actual, nulTerm, __FILE__, __LINE__)
91
92
test_assert_utext(const char * expected,UText * actual,const char * file,int line)93 static void test_assert_utext(const char *expected, UText *actual, const char *file, int line) {
94 UErrorCode status = U_ZERO_ERROR;
95 UText expectedText = UTEXT_INITIALIZER;
96 utext_openUTF8(&expectedText, expected, -1, &status);
97 utext_setNativeIndex(actual, 0);
98 if (utext_compare(&expectedText, -1, actual, -1) != 0) {
99 UChar32 c;
100 log_err("Failure at file %s, line %d, expected \"%s\", got \"", file, line, expected);
101 c = utext_next32From(actual, 0);
102 while (c != U_SENTINEL) {
103 if (0x20<c && c <0x7e) {
104 log_err("%c", c);
105 } else {
106 log_err("%#x", c);
107 }
108 c = UTEXT_NEXT32(actual);
109 }
110 log_err("\"\n");
111 }
112 utext_close(&expectedText);
113 }
114
115 #define TEST_ASSERT_UTEXT(expected, actual) test_assert_utext(expected, actual, __FILE__, __LINE__)
116
117
118
119 static void TestRegexCAPI(void);
120 static void TestBug4315(void);
121 static void TestUTextAPI(void);
122
123 void addURegexTest(TestNode** root);
124
addURegexTest(TestNode ** root)125 void addURegexTest(TestNode** root)
126 {
127 addTest(root, &TestRegexCAPI, "regex/TestRegexCAPI");
128 addTest(root, &TestBug4315, "regex/TestBug4315");
129 addTest(root, &TestUTextAPI, "regex/TestUTextAPI");
130 }
131
132 /*
133 * Call back function and context struct used for testing
134 * regular expression user callbacks. This test is mostly the same as
135 * the corresponding C++ test in intltest.
136 */
137 typedef struct callBackContext {
138 int32_t maxCalls;
139 int32_t numCalls;
140 int32_t lastSteps;
141 } callBackContext;
142
143 static UBool U_EXPORT2 U_CALLCONV
TestCallbackFn(const void * context,int32_t steps)144 TestCallbackFn(const void *context, int32_t steps) {
145 callBackContext *info = (callBackContext *)context;
146 if (info->lastSteps+1 != steps) {
147 log_err("incorrect steps in callback. Expected %d, got %d\n", info->lastSteps+1, steps);
148 }
149 info->lastSteps = steps;
150 info->numCalls++;
151 return (info->numCalls < info->maxCalls);
152 }
153
154 /*
155 * Regular Expression C API Tests
156 */
TestRegexCAPI(void)157 static void TestRegexCAPI(void) {
158 UErrorCode status = U_ZERO_ERROR;
159 URegularExpression *re;
160 UChar pat[200];
161 UChar *minus1;
162
163 memset(&minus1, -1, sizeof(minus1));
164
165 /* Mimimalist open/close */
166 u_uastrncpy(pat, "abc*", sizeof(pat)/2);
167 re = uregex_open(pat, -1, 0, 0, &status);
168 if (U_FAILURE(status)) {
169 log_data_err("Failed to open regular expression, %s:%d, error is \"%s\" (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));
170 return;
171 }
172 uregex_close(re);
173
174 /* Open with all flag values set */
175 status = U_ZERO_ERROR;
176 re = uregex_open(pat, -1,
177 UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD,
178 0, &status);
179 TEST_ASSERT_SUCCESS(status);
180 uregex_close(re);
181
182 /* Open with an invalid flag */
183 status = U_ZERO_ERROR;
184 re = uregex_open(pat, -1, 0x40000000, 0, &status);
185 TEST_ASSERT(status == U_REGEX_INVALID_FLAG);
186 uregex_close(re);
187
188 /* Open with an unimplemented flag */
189 status = U_ZERO_ERROR;
190 re = uregex_open(pat, -1, UREGEX_LITERAL, 0, &status);
191 TEST_ASSERT(status == U_REGEX_UNIMPLEMENTED);
192 uregex_close(re);
193
194 /* openC with an invalid parameter */
195 status = U_ZERO_ERROR;
196 re = uregex_openC(NULL,
197 UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD, 0, &status);
198 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR && re == NULL);
199
200 /* openC with an invalid parameter */
201 status = U_USELESS_COLLATOR_ERROR;
202 re = uregex_openC(NULL,
203 UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD, 0, &status);
204 TEST_ASSERT(status == U_USELESS_COLLATOR_ERROR && re == NULL);
205
206 /* openC open from a C string */
207 {
208 const UChar *p;
209 int32_t len;
210 status = U_ZERO_ERROR;
211 re = uregex_openC("abc*", 0, 0, &status);
212 TEST_ASSERT_SUCCESS(status);
213 p = uregex_pattern(re, &len, &status);
214 TEST_ASSERT_SUCCESS(status);
215
216 /* The TEST_ASSERT_SUCCESS above should change too... */
217 if(U_SUCCESS(status)) {
218 u_uastrncpy(pat, "abc*", sizeof(pat)/2);
219 TEST_ASSERT(u_strcmp(pat, p) == 0);
220 TEST_ASSERT(len==(int32_t)strlen("abc*"));
221 }
222
223 uregex_close(re);
224
225 /* TODO: Open with ParseError parameter */
226 }
227
228 /*
229 * clone
230 */
231 {
232 URegularExpression *clone1;
233 URegularExpression *clone2;
234 URegularExpression *clone3;
235 UChar testString1[30];
236 UChar testString2[30];
237 UBool result;
238
239
240 status = U_ZERO_ERROR;
241 re = uregex_openC("abc*", 0, 0, &status);
242 TEST_ASSERT_SUCCESS(status);
243 clone1 = uregex_clone(re, &status);
244 TEST_ASSERT_SUCCESS(status);
245 TEST_ASSERT(clone1 != NULL);
246
247 status = U_ZERO_ERROR;
248 clone2 = uregex_clone(re, &status);
249 TEST_ASSERT_SUCCESS(status);
250 TEST_ASSERT(clone2 != NULL);
251 uregex_close(re);
252
253 status = U_ZERO_ERROR;
254 clone3 = uregex_clone(clone2, &status);
255 TEST_ASSERT_SUCCESS(status);
256 TEST_ASSERT(clone3 != NULL);
257
258 u_uastrncpy(testString1, "abcccd", sizeof(pat)/2);
259 u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2);
260
261 status = U_ZERO_ERROR;
262 uregex_setText(clone1, testString1, -1, &status);
263 TEST_ASSERT_SUCCESS(status);
264 result = uregex_lookingAt(clone1, 0, &status);
265 TEST_ASSERT_SUCCESS(status);
266 TEST_ASSERT(result==TRUE);
267
268 status = U_ZERO_ERROR;
269 uregex_setText(clone2, testString2, -1, &status);
270 TEST_ASSERT_SUCCESS(status);
271 result = uregex_lookingAt(clone2, 0, &status);
272 TEST_ASSERT_SUCCESS(status);
273 TEST_ASSERT(result==FALSE);
274 result = uregex_find(clone2, 0, &status);
275 TEST_ASSERT_SUCCESS(status);
276 TEST_ASSERT(result==TRUE);
277
278 uregex_close(clone1);
279 uregex_close(clone2);
280 uregex_close(clone3);
281
282 }
283
284 /*
285 * pattern()
286 */
287 {
288 const UChar *resultPat;
289 int32_t resultLen;
290 u_uastrncpy(pat, "hello", sizeof(pat)/2);
291 status = U_ZERO_ERROR;
292 re = uregex_open(pat, -1, 0, NULL, &status);
293 resultPat = uregex_pattern(re, &resultLen, &status);
294 TEST_ASSERT_SUCCESS(status);
295
296 /* The TEST_ASSERT_SUCCESS above should change too... */
297 if (U_SUCCESS(status)) {
298 TEST_ASSERT(resultLen == -1);
299 TEST_ASSERT(u_strcmp(resultPat, pat) == 0);
300 }
301
302 uregex_close(re);
303
304 status = U_ZERO_ERROR;
305 re = uregex_open(pat, 3, 0, NULL, &status);
306 resultPat = uregex_pattern(re, &resultLen, &status);
307 TEST_ASSERT_SUCCESS(status);
308 TEST_ASSERT_SUCCESS(status);
309
310 /* The TEST_ASSERT_SUCCESS above should change too... */
311 if (U_SUCCESS(status)) {
312 TEST_ASSERT(resultLen == 3);
313 TEST_ASSERT(u_strncmp(resultPat, pat, 3) == 0);
314 TEST_ASSERT(u_strlen(resultPat) == 3);
315 }
316
317 uregex_close(re);
318 }
319
320 /*
321 * flags()
322 */
323 {
324 int32_t t;
325
326 status = U_ZERO_ERROR;
327 re = uregex_open(pat, -1, 0, NULL, &status);
328 t = uregex_flags(re, &status);
329 TEST_ASSERT_SUCCESS(status);
330 TEST_ASSERT(t == 0);
331 uregex_close(re);
332
333 status = U_ZERO_ERROR;
334 re = uregex_open(pat, -1, 0, NULL, &status);
335 t = uregex_flags(re, &status);
336 TEST_ASSERT_SUCCESS(status);
337 TEST_ASSERT(t == 0);
338 uregex_close(re);
339
340 status = U_ZERO_ERROR;
341 re = uregex_open(pat, -1, UREGEX_CASE_INSENSITIVE | UREGEX_DOTALL, NULL, &status);
342 t = uregex_flags(re, &status);
343 TEST_ASSERT_SUCCESS(status);
344 TEST_ASSERT(t == (UREGEX_CASE_INSENSITIVE | UREGEX_DOTALL));
345 uregex_close(re);
346 }
347
348 /*
349 * setText() and lookingAt()
350 */
351 {
352 UChar text1[50];
353 UChar text2[50];
354 UBool result;
355
356 u_uastrncpy(text1, "abcccd", sizeof(text1)/2);
357 u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
358 status = U_ZERO_ERROR;
359 u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
360 re = uregex_open(pat, -1, 0, NULL, &status);
361 TEST_ASSERT_SUCCESS(status);
362
363 /* Operation before doing a setText should fail... */
364 status = U_ZERO_ERROR;
365 uregex_lookingAt(re, 0, &status);
366 TEST_ASSERT( status== U_REGEX_INVALID_STATE);
367
368 status = U_ZERO_ERROR;
369 uregex_setText(re, text1, -1, &status);
370 result = uregex_lookingAt(re, 0, &status);
371 TEST_ASSERT(result == TRUE);
372 TEST_ASSERT_SUCCESS(status);
373
374 status = U_ZERO_ERROR;
375 uregex_setText(re, text2, -1, &status);
376 result = uregex_lookingAt(re, 0, &status);
377 TEST_ASSERT(result == FALSE);
378 TEST_ASSERT_SUCCESS(status);
379
380 status = U_ZERO_ERROR;
381 uregex_setText(re, text1, -1, &status);
382 result = uregex_lookingAt(re, 0, &status);
383 TEST_ASSERT(result == TRUE);
384 TEST_ASSERT_SUCCESS(status);
385
386 status = U_ZERO_ERROR;
387 uregex_setText(re, text1, 5, &status);
388 result = uregex_lookingAt(re, 0, &status);
389 TEST_ASSERT(result == FALSE);
390 TEST_ASSERT_SUCCESS(status);
391
392 status = U_ZERO_ERROR;
393 uregex_setText(re, text1, 6, &status);
394 result = uregex_lookingAt(re, 0, &status);
395 TEST_ASSERT(result == TRUE);
396 TEST_ASSERT_SUCCESS(status);
397
398 uregex_close(re);
399 }
400
401
402 /*
403 * getText()
404 */
405 {
406 UChar text1[50];
407 UChar text2[50];
408 const UChar *result;
409 int32_t textLength;
410
411 u_uastrncpy(text1, "abcccd", sizeof(text1)/2);
412 u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
413 status = U_ZERO_ERROR;
414 u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
415 re = uregex_open(pat, -1, 0, NULL, &status);
416
417 uregex_setText(re, text1, -1, &status);
418 result = uregex_getText(re, &textLength, &status);
419 TEST_ASSERT(result == text1);
420 TEST_ASSERT(textLength == -1);
421 TEST_ASSERT_SUCCESS(status);
422
423 status = U_ZERO_ERROR;
424 uregex_setText(re, text2, 7, &status);
425 result = uregex_getText(re, &textLength, &status);
426 TEST_ASSERT(result == text2);
427 TEST_ASSERT(textLength == 7);
428 TEST_ASSERT_SUCCESS(status);
429
430 status = U_ZERO_ERROR;
431 uregex_setText(re, text2, 4, &status);
432 result = uregex_getText(re, &textLength, &status);
433 TEST_ASSERT(result == text2);
434 TEST_ASSERT(textLength == 4);
435 TEST_ASSERT_SUCCESS(status);
436 uregex_close(re);
437 }
438
439 /*
440 * matches()
441 */
442 {
443 UChar text1[50];
444 UBool result;
445 int len;
446 UChar nullString[] = {0,0,0};
447
448 u_uastrncpy(text1, "abcccde", sizeof(text1)/2);
449 status = U_ZERO_ERROR;
450 u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
451 re = uregex_open(pat, -1, 0, NULL, &status);
452
453 uregex_setText(re, text1, -1, &status);
454 result = uregex_matches(re, 0, &status);
455 TEST_ASSERT(result == FALSE);
456 TEST_ASSERT_SUCCESS(status);
457
458 status = U_ZERO_ERROR;
459 uregex_setText(re, text1, 6, &status);
460 result = uregex_matches(re, 0, &status);
461 TEST_ASSERT(result == TRUE);
462 TEST_ASSERT_SUCCESS(status);
463
464 status = U_ZERO_ERROR;
465 uregex_setText(re, text1, 6, &status);
466 result = uregex_matches(re, 1, &status);
467 TEST_ASSERT(result == FALSE);
468 TEST_ASSERT_SUCCESS(status);
469 uregex_close(re);
470
471 status = U_ZERO_ERROR;
472 re = uregex_openC(".?", 0, NULL, &status);
473 uregex_setText(re, text1, -1, &status);
474 len = u_strlen(text1);
475 result = uregex_matches(re, len, &status);
476 TEST_ASSERT(result == TRUE);
477 TEST_ASSERT_SUCCESS(status);
478
479 status = U_ZERO_ERROR;
480 uregex_setText(re, nullString, -1, &status);
481 TEST_ASSERT_SUCCESS(status);
482 result = uregex_matches(re, 0, &status);
483 TEST_ASSERT(result == TRUE);
484 TEST_ASSERT_SUCCESS(status);
485 uregex_close(re);
486 }
487
488
489 /*
490 * lookingAt() Used in setText test.
491 */
492
493
494 /*
495 * find(), findNext, start, end, reset
496 */
497 {
498 UChar text1[50];
499 UBool result;
500 u_uastrncpy(text1, "012rx5rx890rxrx...", sizeof(text1)/2);
501 status = U_ZERO_ERROR;
502 re = uregex_openC("rx", 0, NULL, &status);
503
504 uregex_setText(re, text1, -1, &status);
505 result = uregex_find(re, 0, &status);
506 TEST_ASSERT(result == TRUE);
507 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
508 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
509 TEST_ASSERT_SUCCESS(status);
510
511 result = uregex_find(re, 9, &status);
512 TEST_ASSERT(result == TRUE);
513 TEST_ASSERT(uregex_start(re, 0, &status) == 11);
514 TEST_ASSERT(uregex_end(re, 0, &status) == 13);
515 TEST_ASSERT_SUCCESS(status);
516
517 result = uregex_find(re, 14, &status);
518 TEST_ASSERT(result == FALSE);
519 TEST_ASSERT_SUCCESS(status);
520
521 status = U_ZERO_ERROR;
522 uregex_reset(re, 0, &status);
523
524 result = uregex_findNext(re, &status);
525 TEST_ASSERT(result == TRUE);
526 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
527 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
528 TEST_ASSERT_SUCCESS(status);
529
530 result = uregex_findNext(re, &status);
531 TEST_ASSERT(result == TRUE);
532 TEST_ASSERT(uregex_start(re, 0, &status) == 6);
533 TEST_ASSERT(uregex_end(re, 0, &status) == 8);
534 TEST_ASSERT_SUCCESS(status);
535
536 status = U_ZERO_ERROR;
537 uregex_reset(re, 12, &status);
538
539 result = uregex_findNext(re, &status);
540 TEST_ASSERT(result == TRUE);
541 TEST_ASSERT(uregex_start(re, 0, &status) == 13);
542 TEST_ASSERT(uregex_end(re, 0, &status) == 15);
543 TEST_ASSERT_SUCCESS(status);
544
545 result = uregex_findNext(re, &status);
546 TEST_ASSERT(result == FALSE);
547 TEST_ASSERT_SUCCESS(status);
548
549 uregex_close(re);
550 }
551
552 /*
553 * groupCount
554 */
555 {
556 int32_t result;
557
558 status = U_ZERO_ERROR;
559 re = uregex_openC("abc", 0, NULL, &status);
560 result = uregex_groupCount(re, &status);
561 TEST_ASSERT_SUCCESS(status);
562 TEST_ASSERT(result == 0);
563 uregex_close(re);
564
565 status = U_ZERO_ERROR;
566 re = uregex_openC("abc(def)(ghi(j))", 0, NULL, &status);
567 result = uregex_groupCount(re, &status);
568 TEST_ASSERT_SUCCESS(status);
569 TEST_ASSERT(result == 3);
570 uregex_close(re);
571
572 }
573
574
575 /*
576 * group()
577 */
578 {
579 UChar text1[80];
580 UChar buf[80];
581 UBool result;
582 int32_t resultSz;
583 u_uastrncpy(text1, "noise abc interior def, and this is off the end", sizeof(text1)/2);
584
585 status = U_ZERO_ERROR;
586 re = uregex_openC("abc(.*?)def", 0, NULL, &status);
587 TEST_ASSERT_SUCCESS(status);
588
589
590 uregex_setText(re, text1, -1, &status);
591 result = uregex_find(re, 0, &status);
592 TEST_ASSERT(result==TRUE);
593
594 /* Capture Group 0, the full match. Should succeed. */
595 status = U_ZERO_ERROR;
596 resultSz = uregex_group(re, 0, buf, sizeof(buf)/2, &status);
597 TEST_ASSERT_SUCCESS(status);
598 TEST_ASSERT_STRING("abc interior def", buf, TRUE);
599 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
600
601 /* Capture group #1. Should succeed. */
602 status = U_ZERO_ERROR;
603 resultSz = uregex_group(re, 1, buf, sizeof(buf)/2, &status);
604 TEST_ASSERT_SUCCESS(status);
605 TEST_ASSERT_STRING(" interior ", buf, TRUE);
606 TEST_ASSERT(resultSz == (int32_t)strlen(" interior "));
607
608 /* Capture group out of range. Error. */
609 status = U_ZERO_ERROR;
610 uregex_group(re, 2, buf, sizeof(buf)/2, &status);
611 TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
612
613 /* NULL buffer, pure pre-flight */
614 status = U_ZERO_ERROR;
615 resultSz = uregex_group(re, 0, NULL, 0, &status);
616 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
617 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
618
619 /* Too small buffer, truncated string */
620 status = U_ZERO_ERROR;
621 memset(buf, -1, sizeof(buf));
622 resultSz = uregex_group(re, 0, buf, 5, &status);
623 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
624 TEST_ASSERT_STRING("abc i", buf, FALSE);
625 TEST_ASSERT(buf[5] == (UChar)0xffff);
626 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
627
628 /* Output string just fits buffer, no NUL term. */
629 status = U_ZERO_ERROR;
630 resultSz = uregex_group(re, 0, buf, (int32_t)strlen("abc interior def"), &status);
631 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
632 TEST_ASSERT_STRING("abc interior def", buf, FALSE);
633 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
634 TEST_ASSERT(buf[strlen("abc interior def")] == (UChar)0xffff);
635
636 uregex_close(re);
637
638 }
639
640 /*
641 * Regions
642 */
643
644
645 /* SetRegion(), getRegion() do something */
646 TEST_SETUP(".*", "0123456789ABCDEF", 0)
647 UChar resultString[40];
648 TEST_ASSERT(uregex_regionStart(re, &status) == 0);
649 TEST_ASSERT(uregex_regionEnd(re, &status) == 16);
650 uregex_setRegion(re, 3, 6, &status);
651 TEST_ASSERT(uregex_regionStart(re, &status) == 3);
652 TEST_ASSERT(uregex_regionEnd(re, &status) == 6);
653 TEST_ASSERT(uregex_findNext(re, &status));
654 TEST_ASSERT(uregex_group(re, 0, resultString, sizeof(resultString)/2, &status) == 3)
655 TEST_ASSERT_STRING("345", resultString, TRUE);
656 TEST_TEARDOWN;
657
658 /* find(start=-1) uses regions */
659 TEST_SETUP(".*", "0123456789ABCDEF", 0);
660 uregex_setRegion(re, 4, 6, &status);
661 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
662 TEST_ASSERT(uregex_start(re, 0, &status) == 4);
663 TEST_ASSERT(uregex_end(re, 0, &status) == 6);
664 TEST_TEARDOWN;
665
666 /* find (start >=0) does not use regions */
667 TEST_SETUP(".*", "0123456789ABCDEF", 0);
668 uregex_setRegion(re, 4, 6, &status);
669 TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
670 TEST_ASSERT(uregex_start(re, 0, &status) == 0);
671 TEST_ASSERT(uregex_end(re, 0, &status) == 16);
672 TEST_TEARDOWN;
673
674 /* findNext() obeys regions */
675 TEST_SETUP(".", "0123456789ABCDEF", 0);
676 uregex_setRegion(re, 4, 6, &status);
677 TEST_ASSERT(uregex_findNext(re,&status) == TRUE);
678 TEST_ASSERT(uregex_start(re, 0, &status) == 4);
679 TEST_ASSERT(uregex_findNext(re, &status) == TRUE);
680 TEST_ASSERT(uregex_start(re, 0, &status) == 5);
681 TEST_ASSERT(uregex_findNext(re, &status) == FALSE);
682 TEST_TEARDOWN;
683
684 /* matches(start=-1) uses regions */
685 /* Also, verify that non-greedy *? succeeds in finding the full match. */
686 TEST_SETUP(".*?", "0123456789ABCDEF", 0);
687 uregex_setRegion(re, 4, 6, &status);
688 TEST_ASSERT(uregex_matches(re, -1, &status) == TRUE);
689 TEST_ASSERT(uregex_start(re, 0, &status) == 4);
690 TEST_ASSERT(uregex_end(re, 0, &status) == 6);
691 TEST_TEARDOWN;
692
693 /* matches (start >=0) does not use regions */
694 TEST_SETUP(".*?", "0123456789ABCDEF", 0);
695 uregex_setRegion(re, 4, 6, &status);
696 TEST_ASSERT(uregex_matches(re, 0, &status) == TRUE);
697 TEST_ASSERT(uregex_start(re, 0, &status) == 0);
698 TEST_ASSERT(uregex_end(re, 0, &status) == 16);
699 TEST_TEARDOWN;
700
701 /* lookingAt(start=-1) uses regions */
702 /* Also, verify that non-greedy *? finds the first (shortest) match. */
703 TEST_SETUP(".*?", "0123456789ABCDEF", 0);
704 uregex_setRegion(re, 4, 6, &status);
705 TEST_ASSERT(uregex_lookingAt(re, -1, &status) == TRUE);
706 TEST_ASSERT(uregex_start(re, 0, &status) == 4);
707 TEST_ASSERT(uregex_end(re, 0, &status) == 4);
708 TEST_TEARDOWN;
709
710 /* lookingAt (start >=0) does not use regions */
711 TEST_SETUP(".*?", "0123456789ABCDEF", 0);
712 uregex_setRegion(re, 4, 6, &status);
713 TEST_ASSERT(uregex_lookingAt(re, 0, &status) == TRUE);
714 TEST_ASSERT(uregex_start(re, 0, &status) == 0);
715 TEST_ASSERT(uregex_end(re, 0, &status) == 0);
716 TEST_TEARDOWN;
717
718 /* hitEnd() */
719 TEST_SETUP("[a-f]*", "abcdefghij", 0);
720 TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
721 TEST_ASSERT(uregex_hitEnd(re, &status) == FALSE);
722 TEST_TEARDOWN;
723
724 TEST_SETUP("[a-f]*", "abcdef", 0);
725 TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
726 TEST_ASSERT(uregex_hitEnd(re, &status) == TRUE);
727 TEST_TEARDOWN;
728
729 /* requireEnd */
730 TEST_SETUP("abcd", "abcd", 0);
731 TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
732 TEST_ASSERT(uregex_requireEnd(re, &status) == FALSE);
733 TEST_TEARDOWN;
734
735 TEST_SETUP("abcd$", "abcd", 0);
736 TEST_ASSERT(uregex_find(re, 0, &status) == TRUE);
737 TEST_ASSERT(uregex_requireEnd(re, &status) == TRUE);
738 TEST_TEARDOWN;
739
740 /* anchoringBounds */
741 TEST_SETUP("abc$", "abcdef", 0);
742 TEST_ASSERT(uregex_hasAnchoringBounds(re, &status) == TRUE);
743 uregex_useAnchoringBounds(re, FALSE, &status);
744 TEST_ASSERT(uregex_hasAnchoringBounds(re, &status) == FALSE);
745
746 TEST_ASSERT(uregex_find(re, -1, &status) == FALSE);
747 uregex_useAnchoringBounds(re, TRUE, &status);
748 uregex_setRegion(re, 0, 3, &status);
749 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
750 TEST_ASSERT(uregex_end(re, 0, &status) == 3);
751 TEST_TEARDOWN;
752
753 /* Transparent Bounds */
754 TEST_SETUP("abc(?=def)", "abcdef", 0);
755 TEST_ASSERT(uregex_hasTransparentBounds(re, &status) == FALSE);
756 uregex_useTransparentBounds(re, TRUE, &status);
757 TEST_ASSERT(uregex_hasTransparentBounds(re, &status) == TRUE);
758
759 uregex_useTransparentBounds(re, FALSE, &status);
760 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE); /* No Region */
761 uregex_setRegion(re, 0, 3, &status);
762 TEST_ASSERT(uregex_find(re, -1, &status) == FALSE); /* with region, opaque bounds */
763 uregex_useTransparentBounds(re, TRUE, &status);
764 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE); /* with region, transparent bounds */
765 TEST_ASSERT(uregex_end(re, 0, &status) == 3);
766 TEST_TEARDOWN;
767
768
769 /*
770 * replaceFirst()
771 */
772 {
773 UChar text1[80];
774 UChar text2[80];
775 UChar replText[80];
776 UChar buf[80];
777 int32_t resultSz;
778 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
779 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
780 u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
781
782 status = U_ZERO_ERROR;
783 re = uregex_openC("x(.*?)x", 0, NULL, &status);
784 TEST_ASSERT_SUCCESS(status);
785
786 /* Normal case, with match */
787 uregex_setText(re, text1, -1, &status);
788 resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
789 TEST_ASSERT_SUCCESS(status);
790 TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, TRUE);
791 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
792
793 /* No match. Text should copy to output with no changes. */
794 status = U_ZERO_ERROR;
795 uregex_setText(re, text2, -1, &status);
796 resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
797 TEST_ASSERT_SUCCESS(status);
798 TEST_ASSERT_STRING("No match here.", buf, TRUE);
799 TEST_ASSERT(resultSz == (int32_t)strlen("No match here."));
800
801 /* Match, output just fills buffer, no termination warning. */
802 status = U_ZERO_ERROR;
803 uregex_setText(re, text1, -1, &status);
804 memset(buf, -1, sizeof(buf));
805 resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x."), &status);
806 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
807 TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, FALSE);
808 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
809 TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
810
811 /* Do the replaceFirst again, without first resetting anything.
812 * Should give the same results.
813 */
814 status = U_ZERO_ERROR;
815 memset(buf, -1, sizeof(buf));
816 resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x."), &status);
817 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
818 TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, FALSE);
819 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
820 TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
821
822 /* NULL buffer, zero buffer length */
823 status = U_ZERO_ERROR;
824 resultSz = uregex_replaceFirst(re, replText, -1, NULL, 0, &status);
825 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
826 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
827
828 /* Buffer too small by one */
829 status = U_ZERO_ERROR;
830 memset(buf, -1, sizeof(buf));
831 resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x.")-1, &status);
832 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
833 TEST_ASSERT_STRING("Replace <aa> x1x x...x", buf, FALSE);
834 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
835 TEST_ASSERT(buf[resultSz] == (UChar)0xffff);
836
837 uregex_close(re);
838 }
839
840
841 /*
842 * replaceAll()
843 */
844 {
845 UChar text1[80]; /* "Replace xaax x1x x...x." */
846 UChar text2[80]; /* "No match Here" */
847 UChar replText[80]; /* "<$1>" */
848 UChar replText2[80]; /* "<<$1>>" */
849 const char * pattern = "x(.*?)x";
850 const char * expectedResult = "Replace <aa> <1> <...>.";
851 const char * expectedResult2 = "Replace <<aa>> <<1>> <<...>>.";
852 UChar buf[80];
853 int32_t resultSize;
854 int32_t expectedResultSize;
855 int32_t expectedResultSize2;
856 int32_t i;
857
858 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
859 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
860 u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
861 u_uastrncpy(replText2, "<<$1>>", sizeof(replText2)/2);
862 expectedResultSize = strlen(expectedResult);
863 expectedResultSize2 = strlen(expectedResult2);
864
865 status = U_ZERO_ERROR;
866 re = uregex_openC(pattern, 0, NULL, &status);
867 TEST_ASSERT_SUCCESS(status);
868
869 /* Normal case, with match */
870 uregex_setText(re, text1, -1, &status);
871 resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
872 TEST_ASSERT_SUCCESS(status);
873 TEST_ASSERT_STRING(expectedResult, buf, TRUE);
874 TEST_ASSERT(resultSize == expectedResultSize);
875
876 /* No match. Text should copy to output with no changes. */
877 status = U_ZERO_ERROR;
878 uregex_setText(re, text2, -1, &status);
879 resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
880 TEST_ASSERT_SUCCESS(status);
881 TEST_ASSERT_STRING("No match here.", buf, TRUE);
882 TEST_ASSERT(resultSize == u_strlen(text2));
883
884 /* Match, output just fills buffer, no termination warning. */
885 status = U_ZERO_ERROR;
886 uregex_setText(re, text1, -1, &status);
887 memset(buf, -1, sizeof(buf));
888 resultSize = uregex_replaceAll(re, replText, -1, buf, expectedResultSize, &status);
889 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
890 TEST_ASSERT_STRING(expectedResult, buf, FALSE);
891 TEST_ASSERT(resultSize == expectedResultSize);
892 TEST_ASSERT(buf[resultSize] == (UChar)0xffff);
893
894 /* Do the replaceFirst again, without first resetting anything.
895 * Should give the same results.
896 */
897 status = U_ZERO_ERROR;
898 memset(buf, -1, sizeof(buf));
899 resultSize = uregex_replaceAll(re, replText, -1, buf, strlen("Replace xaax x1x x...x."), &status);
900 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
901 TEST_ASSERT_STRING("Replace <aa> <1> <...>.", buf, FALSE);
902 TEST_ASSERT(resultSize == (int32_t)strlen("Replace <aa> <1> <...>."));
903 TEST_ASSERT(buf[resultSize] == (UChar)0xffff);
904
905 /* NULL buffer, zero buffer length */
906 status = U_ZERO_ERROR;
907 resultSize = uregex_replaceAll(re, replText, -1, NULL, 0, &status);
908 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
909 TEST_ASSERT(resultSize == (int32_t)strlen("Replace <aa> <1> <...>."));
910
911 /* Buffer too small. Try every size, which will tickle edge cases
912 * in uregex_appendReplacement (used by replaceAll) */
913 for (i=0; i<expectedResultSize; i++) {
914 char expected[80];
915 status = U_ZERO_ERROR;
916 memset(buf, -1, sizeof(buf));
917 resultSize = uregex_replaceAll(re, replText, -1, buf, i, &status);
918 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
919 strcpy(expected, expectedResult);
920 expected[i] = 0;
921 TEST_ASSERT_STRING(expected, buf, FALSE);
922 TEST_ASSERT(resultSize == expectedResultSize);
923 TEST_ASSERT(buf[i] == (UChar)0xffff);
924 }
925
926 /* Buffer too small. Same as previous test, except this time the replacement
927 * text is longer than the match capture group, making the length of the complete
928 * replacement longer than the original string.
929 */
930 for (i=0; i<expectedResultSize2; i++) {
931 char expected[80];
932 status = U_ZERO_ERROR;
933 memset(buf, -1, sizeof(buf));
934 resultSize = uregex_replaceAll(re, replText2, -1, buf, i, &status);
935 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
936 strcpy(expected, expectedResult2);
937 expected[i] = 0;
938 TEST_ASSERT_STRING(expected, buf, FALSE);
939 TEST_ASSERT(resultSize == expectedResultSize2);
940 TEST_ASSERT(buf[i] == (UChar)0xffff);
941 }
942
943
944 uregex_close(re);
945 }
946
947
948 /*
949 * appendReplacement()
950 */
951 {
952 UChar text[100];
953 UChar repl[100];
954 UChar buf[100];
955 UChar *bufPtr;
956 int32_t bufCap;
957
958
959 status = U_ZERO_ERROR;
960 re = uregex_openC(".*", 0, 0, &status);
961 TEST_ASSERT_SUCCESS(status);
962
963 u_uastrncpy(text, "whatever", sizeof(text)/2);
964 u_uastrncpy(repl, "some other", sizeof(repl)/2);
965 uregex_setText(re, text, -1, &status);
966
967 /* match covers whole target string */
968 uregex_find(re, 0, &status);
969 TEST_ASSERT_SUCCESS(status);
970 bufPtr = buf;
971 bufCap = sizeof(buf) / 2;
972 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
973 TEST_ASSERT_SUCCESS(status);
974 TEST_ASSERT_STRING("some other", buf, TRUE);
975
976 /* Match has \u \U escapes */
977 uregex_find(re, 0, &status);
978 TEST_ASSERT_SUCCESS(status);
979 bufPtr = buf;
980 bufCap = sizeof(buf) / 2;
981 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2);
982 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
983 TEST_ASSERT_SUCCESS(status);
984 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE);
985
986 /* Bug 6813, parameter check of NULL destCapacity; crashed before fix. */
987 status = U_ZERO_ERROR;
988 uregex_find(re, 0, &status);
989 TEST_ASSERT_SUCCESS(status);
990 bufPtr = buf;
991 status = U_BUFFER_OVERFLOW_ERROR;
992 uregex_appendReplacement(re, repl, -1, &bufPtr, NULL, &status);
993 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
994
995 uregex_close(re);
996 }
997
998
999 /*
1000 * appendTail(). Checked in ReplaceFirst(), replaceAll().
1001 */
1002
1003 /*
1004 * split()
1005 */
1006 {
1007 UChar textToSplit[80];
1008 UChar text2[80];
1009 UChar buf[200];
1010 UChar *fields[10];
1011 int32_t numFields;
1012 int32_t requiredCapacity;
1013 int32_t spaceNeeded;
1014 int32_t sz;
1015
1016 u_uastrncpy(textToSplit, "first : second: third", sizeof(textToSplit)/2);
1017 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
1018
1019 status = U_ZERO_ERROR;
1020 re = uregex_openC(":", 0, NULL, &status);
1021
1022
1023 /* Simple split */
1024
1025 uregex_setText(re, textToSplit, -1, &status);
1026 TEST_ASSERT_SUCCESS(status);
1027
1028 /* The TEST_ASSERT_SUCCESS call above should change too... */
1029 if (U_SUCCESS(status)) {
1030 memset(fields, -1, sizeof(fields));
1031 numFields =
1032 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
1033 TEST_ASSERT_SUCCESS(status);
1034
1035 /* The TEST_ASSERT_SUCCESS call above should change too... */
1036 if(U_SUCCESS(status)) {
1037 TEST_ASSERT(numFields == 3);
1038 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1039 TEST_ASSERT_STRING(" second", fields[1], TRUE);
1040 TEST_ASSERT_STRING(" third", fields[2], TRUE);
1041 TEST_ASSERT(fields[3] == NULL);
1042
1043 spaceNeeded = u_strlen(textToSplit) -
1044 (numFields - 1) + /* Field delimiters do not appear in output */
1045 numFields; /* Each field gets a NUL terminator */
1046
1047 TEST_ASSERT(spaceNeeded == requiredCapacity);
1048 }
1049 }
1050
1051 uregex_close(re);
1052
1053
1054 /* Split with too few output strings available */
1055 status = U_ZERO_ERROR;
1056 re = uregex_openC(":", 0, NULL, &status);
1057 uregex_setText(re, textToSplit, -1, &status);
1058 TEST_ASSERT_SUCCESS(status);
1059
1060 /* The TEST_ASSERT_SUCCESS call above should change too... */
1061 if(U_SUCCESS(status)) {
1062 memset(fields, -1, sizeof(fields));
1063 numFields =
1064 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
1065 TEST_ASSERT_SUCCESS(status);
1066
1067 /* The TEST_ASSERT_SUCCESS call above should change too... */
1068 if(U_SUCCESS(status)) {
1069 TEST_ASSERT(numFields == 2);
1070 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1071 TEST_ASSERT_STRING(" second: third", fields[1], TRUE);
1072 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
1073
1074 spaceNeeded = u_strlen(textToSplit) -
1075 (numFields - 1) + /* Field delimiters do not appear in output */
1076 numFields; /* Each field gets a NUL terminator */
1077
1078 TEST_ASSERT(spaceNeeded == requiredCapacity);
1079
1080 /* Split with a range of output buffer sizes. */
1081 spaceNeeded = u_strlen(textToSplit) -
1082 (numFields - 1) + /* Field delimiters do not appear in output */
1083 numFields; /* Each field gets a NUL terminator */
1084
1085 for (sz=0; sz < spaceNeeded+1; sz++) {
1086 memset(fields, -1, sizeof(fields));
1087 status = U_ZERO_ERROR;
1088 numFields =
1089 uregex_split(re, buf, sz, &requiredCapacity, fields, 10, &status);
1090 if (sz >= spaceNeeded) {
1091 TEST_ASSERT_SUCCESS(status);
1092 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1093 TEST_ASSERT_STRING(" second", fields[1], TRUE);
1094 TEST_ASSERT_STRING(" third", fields[2], TRUE);
1095 } else {
1096 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
1097 }
1098 TEST_ASSERT(numFields == 3);
1099 TEST_ASSERT(fields[3] == NULL);
1100 TEST_ASSERT(spaceNeeded == requiredCapacity);
1101 }
1102 }
1103 }
1104
1105 uregex_close(re);
1106 }
1107
1108
1109
1110
1111 /* Split(), part 2. Patterns with capture groups. The capture group text
1112 * comes out as additional fields. */
1113 {
1114 UChar textToSplit[80];
1115 UChar buf[200];
1116 UChar *fields[10];
1117 int32_t numFields;
1118 int32_t requiredCapacity;
1119 int32_t spaceNeeded;
1120 int32_t sz;
1121
1122 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", sizeof(textToSplit)/2);
1123
1124 status = U_ZERO_ERROR;
1125 re = uregex_openC("<(.*?)>", 0, NULL, &status);
1126
1127 uregex_setText(re, textToSplit, -1, &status);
1128 TEST_ASSERT_SUCCESS(status);
1129
1130 /* The TEST_ASSERT_SUCCESS call above should change too... */
1131 if(U_SUCCESS(status)) {
1132 memset(fields, -1, sizeof(fields));
1133 numFields =
1134 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
1135 TEST_ASSERT_SUCCESS(status);
1136
1137 /* The TEST_ASSERT_SUCCESS call above should change too... */
1138 if(U_SUCCESS(status)) {
1139 TEST_ASSERT(numFields == 5);
1140 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1141 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1142 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1143 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1144 TEST_ASSERT_STRING(" third", fields[4], TRUE);
1145 TEST_ASSERT(fields[5] == NULL);
1146 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
1147 TEST_ASSERT(spaceNeeded == requiredCapacity);
1148 }
1149 }
1150
1151 /* Split with too few output strings available (2) */
1152 status = U_ZERO_ERROR;
1153 memset(fields, -1, sizeof(fields));
1154 numFields =
1155 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
1156 TEST_ASSERT_SUCCESS(status);
1157
1158 /* The TEST_ASSERT_SUCCESS call above should change too... */
1159 if(U_SUCCESS(status)) {
1160 TEST_ASSERT(numFields == 2);
1161 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1162 TEST_ASSERT_STRING(" second<tag-b> third", fields[1], TRUE);
1163 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
1164
1165 spaceNeeded = strlen("first . second<tag-b> third."); /* "." at NUL positions */
1166 TEST_ASSERT(spaceNeeded == requiredCapacity);
1167 }
1168
1169 /* Split with too few output strings available (3) */
1170 status = U_ZERO_ERROR;
1171 memset(fields, -1, sizeof(fields));
1172 numFields =
1173 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 3, &status);
1174 TEST_ASSERT_SUCCESS(status);
1175
1176 /* The TEST_ASSERT_SUCCESS call above should change too... */
1177 if(U_SUCCESS(status)) {
1178 TEST_ASSERT(numFields == 3);
1179 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1180 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1181 TEST_ASSERT_STRING(" second<tag-b> third", fields[2], TRUE);
1182 TEST_ASSERT(!memcmp(&fields[3],&minus1,sizeof(UChar*)));
1183
1184 spaceNeeded = strlen("first .tag-a. second<tag-b> third."); /* "." at NUL positions */
1185 TEST_ASSERT(spaceNeeded == requiredCapacity);
1186 }
1187
1188 /* Split with just enough output strings available (5) */
1189 status = U_ZERO_ERROR;
1190 memset(fields, -1, sizeof(fields));
1191 numFields =
1192 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 5, &status);
1193 TEST_ASSERT_SUCCESS(status);
1194
1195 /* The TEST_ASSERT_SUCCESS call above should change too... */
1196 if(U_SUCCESS(status)) {
1197 TEST_ASSERT(numFields == 5);
1198 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1199 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1200 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1201 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1202 TEST_ASSERT_STRING(" third", fields[4], TRUE);
1203 TEST_ASSERT(!memcmp(&fields[5],&minus1,sizeof(UChar*)));
1204
1205 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
1206 TEST_ASSERT(spaceNeeded == requiredCapacity);
1207 }
1208
1209 /* Split, end of text is a field delimiter. */
1210 status = U_ZERO_ERROR;
1211 sz = strlen("first <tag-a> second<tag-b>");
1212 uregex_setText(re, textToSplit, sz, &status);
1213 TEST_ASSERT_SUCCESS(status);
1214
1215 /* The TEST_ASSERT_SUCCESS call above should change too... */
1216 if(U_SUCCESS(status)) {
1217 memset(fields, -1, sizeof(fields));
1218 numFields =
1219 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 9, &status);
1220 TEST_ASSERT_SUCCESS(status);
1221
1222 /* The TEST_ASSERT_SUCCESS call above should change too... */
1223 if(U_SUCCESS(status)) {
1224 TEST_ASSERT(numFields == 4);
1225 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1226 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1227 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1228 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1229 TEST_ASSERT(fields[4] == NULL);
1230 TEST_ASSERT(fields[8] == NULL);
1231 TEST_ASSERT(!memcmp(&fields[9],&minus1,sizeof(UChar*)));
1232 spaceNeeded = strlen("first .tag-a. second.tag-b."); /* "." at NUL positions */
1233 TEST_ASSERT(spaceNeeded == requiredCapacity);
1234 }
1235 }
1236
1237 uregex_close(re);
1238 }
1239
1240 /*
1241 * set/getTimeLimit
1242 */
1243 TEST_SETUP("abc$", "abcdef", 0);
1244 TEST_ASSERT(uregex_getTimeLimit(re, &status) == 0);
1245 uregex_setTimeLimit(re, 1000, &status);
1246 TEST_ASSERT(uregex_getTimeLimit(re, &status) == 1000);
1247 TEST_ASSERT_SUCCESS(status);
1248 uregex_setTimeLimit(re, -1, &status);
1249 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
1250 status = U_ZERO_ERROR;
1251 TEST_ASSERT(uregex_getTimeLimit(re, &status) == 1000);
1252 TEST_TEARDOWN;
1253
1254 /*
1255 * set/get Stack Limit
1256 */
1257 TEST_SETUP("abc$", "abcdef", 0);
1258 TEST_ASSERT(uregex_getStackLimit(re, &status) == 8000000);
1259 uregex_setStackLimit(re, 40000, &status);
1260 TEST_ASSERT(uregex_getStackLimit(re, &status) == 40000);
1261 TEST_ASSERT_SUCCESS(status);
1262 uregex_setStackLimit(re, -1, &status);
1263 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
1264 status = U_ZERO_ERROR;
1265 TEST_ASSERT(uregex_getStackLimit(re, &status) == 40000);
1266 TEST_TEARDOWN;
1267
1268
1269 /*
1270 * Get/Set callback functions
1271 * This test is copied from intltest regex/Callbacks
1272 * The pattern and test data will run long enough to cause the callback
1273 * to be invoked. The nested '+' operators give exponential time
1274 * behavior with increasing string length.
1275 */
1276 TEST_SETUP("((.)+\\2)+x", "aaaaaaaaaaaaaaaaaaab", 0)
1277 callBackContext cbInfo = {4, 0, 0};
1278 const void *pContext = &cbInfo;
1279 URegexMatchCallback *returnedFn = &TestCallbackFn;
1280
1281 /* Getting the callback fn when it hasn't been set must return NULL */
1282 uregex_getMatchCallback(re, &returnedFn, &pContext, &status);
1283 TEST_ASSERT_SUCCESS(status);
1284 TEST_ASSERT(returnedFn == NULL);
1285 TEST_ASSERT(pContext == NULL);
1286
1287 /* Set thecallback and do a match. */
1288 /* The callback function should record that it has been called. */
1289 uregex_setMatchCallback(re, &TestCallbackFn, &cbInfo, &status);
1290 TEST_ASSERT_SUCCESS(status);
1291 TEST_ASSERT(cbInfo.numCalls == 0);
1292 TEST_ASSERT(uregex_matches(re, -1, &status) == FALSE);
1293 TEST_ASSERT_SUCCESS(status);
1294 TEST_ASSERT(cbInfo.numCalls > 0);
1295
1296 /* Getting the callback should return the values that were set above. */
1297 uregex_getMatchCallback(re, &returnedFn, &pContext, &status);
1298 TEST_ASSERT(returnedFn == &TestCallbackFn);
1299 TEST_ASSERT(pContext == &cbInfo);
1300
1301 TEST_TEARDOWN;
1302 }
1303
1304
1305
TestBug4315(void)1306 static void TestBug4315(void) {
1307 UErrorCode theICUError = U_ZERO_ERROR;
1308 URegularExpression *theRegEx;
1309 UChar *textBuff;
1310 const char *thePattern;
1311 UChar theString[100];
1312 UChar *destFields[24];
1313 int32_t neededLength1;
1314 int32_t neededLength2;
1315
1316 int32_t wordCount = 0;
1317 int32_t destFieldsSize = 24;
1318
1319 thePattern = "ck ";
1320 u_uastrcpy(theString, "The quick brown fox jumped over the slow black turtle.");
1321
1322 /* open a regex */
1323 theRegEx = uregex_openC(thePattern, 0, NULL, &theICUError);
1324 TEST_ASSERT_SUCCESS(theICUError);
1325
1326 /* set the input string */
1327 uregex_setText(theRegEx, theString, u_strlen(theString), &theICUError);
1328 TEST_ASSERT_SUCCESS(theICUError);
1329
1330 /* split */
1331 /*explicitly pass NULL and 0 to force the overflow error -> this is where the
1332 * error occurs! */
1333 wordCount = uregex_split(theRegEx, NULL, 0, &neededLength1, destFields,
1334 destFieldsSize, &theICUError);
1335
1336 TEST_ASSERT(theICUError == U_BUFFER_OVERFLOW_ERROR);
1337 TEST_ASSERT(wordCount==3);
1338
1339 if(theICUError == U_BUFFER_OVERFLOW_ERROR)
1340 {
1341 theICUError = U_ZERO_ERROR;
1342 textBuff = (UChar *) malloc(sizeof(UChar) * (neededLength1 + 1));
1343 wordCount = uregex_split(theRegEx, textBuff, neededLength1+1, &neededLength2,
1344 destFields, destFieldsSize, &theICUError);
1345 TEST_ASSERT(wordCount==3);
1346 TEST_ASSERT_SUCCESS(theICUError);
1347 TEST_ASSERT(neededLength1 == neededLength2);
1348 TEST_ASSERT_STRING("The qui", destFields[0], TRUE);
1349 TEST_ASSERT_STRING("brown fox jumped over the slow bla", destFields[1], TRUE);
1350 TEST_ASSERT_STRING("turtle.", destFields[2], TRUE);
1351 TEST_ASSERT(destFields[3] == NULL);
1352 free(textBuff);
1353 }
1354 uregex_close(theRegEx);
1355 }
1356
1357 /* Based on TestRegexCAPI() */
TestUTextAPI(void)1358 static void TestUTextAPI(void) {
1359 UErrorCode status = U_ZERO_ERROR;
1360 URegularExpression *re;
1361 UText patternText = UTEXT_INITIALIZER;
1362 UChar pat[200];
1363 const char patternTextUTF8[5] = { 0x61, 0x62, 0x63, 0x2a, 0x00 };
1364
1365 /* Mimimalist open/close */
1366 utext_openUTF8(&patternText, patternTextUTF8, -1, &status);
1367 re = uregex_openUText(&patternText, 0, 0, &status);
1368 if (U_FAILURE(status)) {
1369 log_data_err("Failed to open regular expression, %s:%d, error is \"%s\" (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));
1370 utext_close(&patternText);
1371 return;
1372 }
1373 uregex_close(re);
1374
1375 /* Open with all flag values set */
1376 status = U_ZERO_ERROR;
1377 re = uregex_openUText(&patternText,
1378 UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD,
1379 0, &status);
1380 TEST_ASSERT_SUCCESS(status);
1381 uregex_close(re);
1382
1383 /* Open with an invalid flag */
1384 status = U_ZERO_ERROR;
1385 re = uregex_openUText(&patternText, 0x40000000, 0, &status);
1386 TEST_ASSERT(status == U_REGEX_INVALID_FLAG);
1387 uregex_close(re);
1388
1389 /* open with an invalid parameter */
1390 status = U_ZERO_ERROR;
1391 re = uregex_openUText(NULL,
1392 UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD, 0, &status);
1393 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR && re == NULL);
1394
1395 /*
1396 * clone
1397 */
1398 {
1399 URegularExpression *clone1;
1400 URegularExpression *clone2;
1401 URegularExpression *clone3;
1402 UChar testString1[30];
1403 UChar testString2[30];
1404 UBool result;
1405
1406
1407 status = U_ZERO_ERROR;
1408 re = uregex_openUText(&patternText, 0, 0, &status);
1409 TEST_ASSERT_SUCCESS(status);
1410 clone1 = uregex_clone(re, &status);
1411 TEST_ASSERT_SUCCESS(status);
1412 TEST_ASSERT(clone1 != NULL);
1413
1414 status = U_ZERO_ERROR;
1415 clone2 = uregex_clone(re, &status);
1416 TEST_ASSERT_SUCCESS(status);
1417 TEST_ASSERT(clone2 != NULL);
1418 uregex_close(re);
1419
1420 status = U_ZERO_ERROR;
1421 clone3 = uregex_clone(clone2, &status);
1422 TEST_ASSERT_SUCCESS(status);
1423 TEST_ASSERT(clone3 != NULL);
1424
1425 u_uastrncpy(testString1, "abcccd", sizeof(pat)/2);
1426 u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2);
1427
1428 status = U_ZERO_ERROR;
1429 uregex_setText(clone1, testString1, -1, &status);
1430 TEST_ASSERT_SUCCESS(status);
1431 result = uregex_lookingAt(clone1, 0, &status);
1432 TEST_ASSERT_SUCCESS(status);
1433 TEST_ASSERT(result==TRUE);
1434
1435 status = U_ZERO_ERROR;
1436 uregex_setText(clone2, testString2, -1, &status);
1437 TEST_ASSERT_SUCCESS(status);
1438 result = uregex_lookingAt(clone2, 0, &status);
1439 TEST_ASSERT_SUCCESS(status);
1440 TEST_ASSERT(result==FALSE);
1441 result = uregex_find(clone2, 0, &status);
1442 TEST_ASSERT_SUCCESS(status);
1443 TEST_ASSERT(result==TRUE);
1444
1445 uregex_close(clone1);
1446 uregex_close(clone2);
1447 uregex_close(clone3);
1448
1449 }
1450
1451 /*
1452 * pattern() and patternText()
1453 */
1454 {
1455 const UChar *resultPat;
1456 int32_t resultLen;
1457 UText *resultText;
1458 const char str_hello[] = { 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00 }; /* hello */
1459 const char str_hel[] = { 0x68, 0x65, 0x6c, 0x00 }; /* hel */
1460 u_uastrncpy(pat, "hello", sizeof(pat)/2); /* for comparison */
1461 status = U_ZERO_ERROR;
1462
1463 utext_openUTF8(&patternText, str_hello, -1, &status);
1464 re = uregex_open(pat, -1, 0, NULL, &status);
1465 resultPat = uregex_pattern(re, &resultLen, &status);
1466 TEST_ASSERT_SUCCESS(status);
1467
1468 /* The TEST_ASSERT_SUCCESS above should change too... */
1469 if (U_SUCCESS(status)) {
1470 TEST_ASSERT(resultLen == -1);
1471 TEST_ASSERT(u_strcmp(resultPat, pat) == 0);
1472 }
1473
1474 resultText = uregex_patternUText(re, &status);
1475 TEST_ASSERT_SUCCESS(status);
1476 TEST_ASSERT_UTEXT(str_hello, resultText);
1477
1478 uregex_close(re);
1479
1480 status = U_ZERO_ERROR;
1481 re = uregex_open(pat, 3, 0, NULL, &status);
1482 resultPat = uregex_pattern(re, &resultLen, &status);
1483 TEST_ASSERT_SUCCESS(status);
1484
1485 /* The TEST_ASSERT_SUCCESS above should change too... */
1486 if (U_SUCCESS(status)) {
1487 TEST_ASSERT(resultLen == 3);
1488 TEST_ASSERT(u_strncmp(resultPat, pat, 3) == 0);
1489 TEST_ASSERT(u_strlen(resultPat) == 3);
1490 }
1491
1492 resultText = uregex_patternUText(re, &status);
1493 TEST_ASSERT_SUCCESS(status);
1494 TEST_ASSERT_UTEXT(str_hel, resultText);
1495
1496 uregex_close(re);
1497 }
1498
1499 /*
1500 * setUText() and lookingAt()
1501 */
1502 {
1503 UText text1 = UTEXT_INITIALIZER;
1504 UText text2 = UTEXT_INITIALIZER;
1505 UBool result;
1506 const char str_abcccd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x65, 0x00 }; /* abcccd */
1507 const char str_abcccxd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x79, 0x65, 0x00 }; /* abcccxd */
1508 const char str_abcd[] = { 0x62, 0x63, 0x64, 0x2b, 0x65, 0x00 }; /* abc*d */
1509 status = U_ZERO_ERROR;
1510 utext_openUTF8(&text1, str_abcccd, -1, &status);
1511 utext_openUTF8(&text2, str_abcccxd, -1, &status);
1512
1513 utext_openUTF8(&patternText, str_abcd, -1, &status);
1514 re = uregex_openUText(&patternText, 0, NULL, &status);
1515 TEST_ASSERT_SUCCESS(status);
1516
1517 /* Operation before doing a setText should fail... */
1518 status = U_ZERO_ERROR;
1519 uregex_lookingAt(re, 0, &status);
1520 TEST_ASSERT( status== U_REGEX_INVALID_STATE);
1521
1522 status = U_ZERO_ERROR;
1523 uregex_setUText(re, &text1, &status);
1524 result = uregex_lookingAt(re, 0, &status);
1525 TEST_ASSERT(result == TRUE);
1526 TEST_ASSERT_SUCCESS(status);
1527
1528 status = U_ZERO_ERROR;
1529 uregex_setUText(re, &text2, &status);
1530 result = uregex_lookingAt(re, 0, &status);
1531 TEST_ASSERT(result == FALSE);
1532 TEST_ASSERT_SUCCESS(status);
1533
1534 status = U_ZERO_ERROR;
1535 uregex_setUText(re, &text1, &status);
1536 result = uregex_lookingAt(re, 0, &status);
1537 TEST_ASSERT(result == TRUE);
1538 TEST_ASSERT_SUCCESS(status);
1539
1540 uregex_close(re);
1541 utext_close(&text1);
1542 utext_close(&text2);
1543 }
1544
1545
1546 /*
1547 * getText() and getUText()
1548 */
1549 {
1550 UText text1 = UTEXT_INITIALIZER;
1551 UText text2 = UTEXT_INITIALIZER;
1552 UChar text2Chars[20];
1553 UText *resultText;
1554 const UChar *result;
1555 int32_t textLength;
1556 const char str_abcccd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x65, 0x00 }; /* abcccd */
1557 const char str_abcccxd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x79, 0x65, 0x00 }; /* abcccxd */
1558 const char str_abcd[] = { 0x62, 0x63, 0x64, 0x2b, 0x65, 0x00 }; /* abc*d */
1559
1560
1561 status = U_ZERO_ERROR;
1562 utext_openUTF8(&text1, str_abcccd, -1, &status);
1563 u_uastrncpy(text2Chars, str_abcccxd, sizeof(text2)/2);
1564 utext_openUChars(&text2, text2Chars, -1, &status);
1565
1566 utext_openUTF8(&patternText, str_abcd, -1, &status);
1567 re = uregex_openUText(&patternText, 0, NULL, &status);
1568
1569 /* First set a UText */
1570 uregex_setUText(re, &text1, &status);
1571 resultText = uregex_getUText(re, NULL, &status);
1572 TEST_ASSERT_SUCCESS(status);
1573 TEST_ASSERT(resultText != &text1);
1574 utext_setNativeIndex(resultText, 0);
1575 utext_setNativeIndex(&text1, 0);
1576 TEST_ASSERT(utext_compare(resultText, -1, &text1, -1) == 0);
1577 utext_close(resultText);
1578
1579 result = uregex_getText(re, &textLength, &status); /* flattens UText into buffer */
1580 TEST_ASSERT(textLength == -1 || textLength == 6);
1581 resultText = uregex_getUText(re, NULL, &status);
1582 TEST_ASSERT_SUCCESS(status);
1583 TEST_ASSERT(resultText != &text1);
1584 utext_setNativeIndex(resultText, 0);
1585 utext_setNativeIndex(&text1, 0);
1586 TEST_ASSERT(utext_compare(resultText, -1, &text1, -1) == 0);
1587 utext_close(resultText);
1588
1589 /* Then set a UChar * */
1590 uregex_setText(re, text2Chars, 7, &status);
1591 resultText = uregex_getUText(re, NULL, &status);
1592 TEST_ASSERT_SUCCESS(status);
1593 utext_setNativeIndex(resultText, 0);
1594 utext_setNativeIndex(&text2, 0);
1595 TEST_ASSERT(utext_compare(resultText, -1, &text2, -1) == 0);
1596 utext_close(resultText);
1597 result = uregex_getText(re, &textLength, &status);
1598 TEST_ASSERT(textLength == 7);
1599
1600 uregex_close(re);
1601 utext_close(&text1);
1602 utext_close(&text2);
1603 }
1604
1605 /*
1606 * matches()
1607 */
1608 {
1609 UText text1 = UTEXT_INITIALIZER;
1610 UBool result;
1611 UText nullText = UTEXT_INITIALIZER;
1612 const char str_abcccde[] = { 0x61, 0x62, 0x63, 0x63, 0x63, 0x64, 0x65, 0x00 }; /* abcccde */
1613 const char str_abcd[] = { 0x61, 0x62, 0x63, 0x2a, 0x64, 0x00 }; /* abc*d */
1614
1615 status = U_ZERO_ERROR;
1616 utext_openUTF8(&text1, str_abcccde, -1, &status);
1617 utext_openUTF8(&patternText, str_abcd, -1, &status);
1618 re = uregex_openUText(&patternText, 0, NULL, &status);
1619
1620 uregex_setUText(re, &text1, &status);
1621 result = uregex_matches(re, 0, &status);
1622 TEST_ASSERT(result == FALSE);
1623 TEST_ASSERT_SUCCESS(status);
1624 uregex_close(re);
1625
1626 status = U_ZERO_ERROR;
1627 re = uregex_openC(".?", 0, NULL, &status);
1628 uregex_setUText(re, &text1, &status);
1629 result = uregex_matches(re, 7, &status);
1630 TEST_ASSERT(result == TRUE);
1631 TEST_ASSERT_SUCCESS(status);
1632
1633 status = U_ZERO_ERROR;
1634 utext_openUTF8(&nullText, "", -1, &status);
1635 uregex_setUText(re, &nullText, &status);
1636 TEST_ASSERT_SUCCESS(status);
1637 result = uregex_matches(re, 0, &status);
1638 TEST_ASSERT(result == TRUE);
1639 TEST_ASSERT_SUCCESS(status);
1640
1641 uregex_close(re);
1642 utext_close(&text1);
1643 utext_close(&nullText);
1644 }
1645
1646
1647 /*
1648 * lookingAt() Used in setText test.
1649 */
1650
1651
1652 /*
1653 * find(), findNext, start, end, reset
1654 */
1655 {
1656 UChar text1[50];
1657 UBool result;
1658 u_uastrncpy(text1, "012rx5rx890rxrx...", sizeof(text1)/2);
1659 status = U_ZERO_ERROR;
1660 re = uregex_openC("rx", 0, NULL, &status);
1661
1662 uregex_setText(re, text1, -1, &status);
1663 result = uregex_find(re, 0, &status);
1664 TEST_ASSERT(result == TRUE);
1665 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
1666 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
1667 TEST_ASSERT_SUCCESS(status);
1668
1669 result = uregex_find(re, 9, &status);
1670 TEST_ASSERT(result == TRUE);
1671 TEST_ASSERT(uregex_start(re, 0, &status) == 11);
1672 TEST_ASSERT(uregex_end(re, 0, &status) == 13);
1673 TEST_ASSERT_SUCCESS(status);
1674
1675 result = uregex_find(re, 14, &status);
1676 TEST_ASSERT(result == FALSE);
1677 TEST_ASSERT_SUCCESS(status);
1678
1679 status = U_ZERO_ERROR;
1680 uregex_reset(re, 0, &status);
1681
1682 result = uregex_findNext(re, &status);
1683 TEST_ASSERT(result == TRUE);
1684 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
1685 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
1686 TEST_ASSERT_SUCCESS(status);
1687
1688 result = uregex_findNext(re, &status);
1689 TEST_ASSERT(result == TRUE);
1690 TEST_ASSERT(uregex_start(re, 0, &status) == 6);
1691 TEST_ASSERT(uregex_end(re, 0, &status) == 8);
1692 TEST_ASSERT_SUCCESS(status);
1693
1694 status = U_ZERO_ERROR;
1695 uregex_reset(re, 12, &status);
1696
1697 result = uregex_findNext(re, &status);
1698 TEST_ASSERT(result == TRUE);
1699 TEST_ASSERT(uregex_start(re, 0, &status) == 13);
1700 TEST_ASSERT(uregex_end(re, 0, &status) == 15);
1701 TEST_ASSERT_SUCCESS(status);
1702
1703 result = uregex_findNext(re, &status);
1704 TEST_ASSERT(result == FALSE);
1705 TEST_ASSERT_SUCCESS(status);
1706
1707 uregex_close(re);
1708 }
1709
1710 /*
1711 * group()
1712 */
1713 {
1714 UChar text1[80];
1715 UText *actual;
1716 UBool result;
1717
1718 const char str_abcinteriordef[] = { 0x61, 0x62, 0x63, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x00 }; /* abc interior def */
1719 const char str_interior[] = { 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x00 }; /* ' interior ' */
1720
1721
1722 u_uastrncpy(text1, "noise abc interior def, and this is off the end", sizeof(text1)/2);
1723
1724 status = U_ZERO_ERROR;
1725 re = uregex_openC("abc(.*?)def", 0, NULL, &status);
1726 TEST_ASSERT_SUCCESS(status);
1727
1728 uregex_setText(re, text1, -1, &status);
1729 result = uregex_find(re, 0, &status);
1730 TEST_ASSERT(result==TRUE);
1731
1732 /* Capture Group 0, the full match. Should succeed. */
1733 status = U_ZERO_ERROR;
1734 actual = uregex_groupUTextDeep(re, 0, NULL, &status);
1735 TEST_ASSERT_SUCCESS(status);
1736 TEST_ASSERT_UTEXT(str_abcinteriordef, actual);
1737 utext_close(actual);
1738
1739 /* Capture Group 0 with shallow clone API. Should succeed. */
1740 status = U_ZERO_ERROR;
1741 {
1742 int64_t group_len;
1743 int32_t len16;
1744 UErrorCode shallowStatus = U_ZERO_ERROR;
1745 int64_t nativeIndex;
1746 UChar *groupChars;
1747 UText groupText = UTEXT_INITIALIZER;
1748
1749 actual = uregex_groupUText(re, 0, NULL, &group_len, &status);
1750 TEST_ASSERT_SUCCESS(status);
1751
1752 nativeIndex = utext_getNativeIndex(actual);
1753 /* Following returns U_INDEX_OUTOFBOUNDS_ERROR... looks like a bug in ucstrFuncs UTextFuncs [utext.cpp] */
1754 /* len16 = utext_extract(actual, nativeIndex, nativeIndex + group_len, NULL, 0, &shallowStatus); */
1755 len16 = group_len;
1756
1757 groupChars = (UChar *)malloc(sizeof(UChar)*(len16+1));
1758 utext_extract(actual, nativeIndex, nativeIndex + group_len, groupChars, len16+1, &shallowStatus);
1759
1760 utext_openUChars(&groupText, groupChars, len16, &shallowStatus);
1761
1762 TEST_ASSERT_UTEXT(str_abcinteriordef, &groupText);
1763 utext_close(&groupText);
1764 free(groupChars);
1765 }
1766 utext_close(actual);
1767
1768 /* Capture group #1. Should succeed. */
1769 status = U_ZERO_ERROR;
1770 actual = uregex_groupUTextDeep(re, 1, NULL, &status);
1771 TEST_ASSERT_SUCCESS(status);
1772 TEST_ASSERT_UTEXT(str_interior, actual);
1773 utext_close(actual);
1774
1775 /* Capture group out of range. Error. */
1776 status = U_ZERO_ERROR;
1777 actual = uregex_groupUTextDeep(re, 2, NULL, &status);
1778 TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
1779 TEST_ASSERT(utext_nativeLength(actual) == 0);
1780 utext_close(actual);
1781
1782 uregex_close(re);
1783
1784 }
1785
1786 /*
1787 * replaceFirst()
1788 */
1789 {
1790 UChar text1[80];
1791 UChar text2[80];
1792 UText replText = UTEXT_INITIALIZER;
1793 UText *result;
1794 const char str_Replxxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2e, 0x78, 0x2e, 0x00 }; /* Replace <aa> x1x x...x. */
1795 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
1796 const char str_u00411U00000042a[] = { 0x5c, 0x5c, 0x5c, 0x75, 0x30, 0x30, 0x34, 0x31, 0x24, 0x31, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x24, 0x5c, 0x61, 0x00 }; /* \\\u0041$1\U00000042$\a */
1797 const char str_1x[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
1798 const char str_ReplaceAaaBax1xxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x5c, 0x41, 0x61, 0x61, 0x42, 0x24, 0x61, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2e, 0x78, 0x2e, 0x00 }; /* Replace \AaaB$a x1x x...x. */
1799 status = U_ZERO_ERROR;
1800 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
1801 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
1802 utext_openUTF8(&replText, str_1x, -1, &status);
1803
1804 re = uregex_openC("x(.*?)x", 0, NULL, &status);
1805 TEST_ASSERT_SUCCESS(status);
1806
1807 /* Normal case, with match */
1808 uregex_setText(re, text1, -1, &status);
1809 result = uregex_replaceFirstUText(re, &replText, NULL, &status);
1810 TEST_ASSERT_SUCCESS(status);
1811 TEST_ASSERT_UTEXT(str_Replxxx, result);
1812 utext_close(result);
1813
1814 /* No match. Text should copy to output with no changes. */
1815 uregex_setText(re, text2, -1, &status);
1816 result = uregex_replaceFirstUText(re, &replText, NULL, &status);
1817 TEST_ASSERT_SUCCESS(status);
1818 TEST_ASSERT_UTEXT(str_Nomatchhere, result);
1819 utext_close(result);
1820
1821 /* Unicode escapes */
1822 uregex_setText(re, text1, -1, &status);
1823 utext_openUTF8(&replText, str_u00411U00000042a, -1, &status);
1824 result = uregex_replaceFirstUText(re, &replText, NULL, &status);
1825 TEST_ASSERT_SUCCESS(status);
1826 TEST_ASSERT_UTEXT(str_ReplaceAaaBax1xxx, result);
1827 utext_close(result);
1828
1829 uregex_close(re);
1830 utext_close(&replText);
1831 }
1832
1833
1834 /*
1835 * replaceAll()
1836 */
1837 {
1838 UChar text1[80];
1839 UChar text2[80];
1840 UText replText = UTEXT_INITIALIZER;
1841 UText *result;
1842 const char str_1[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
1843 const char str_Replaceaa1[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x3c, 0x31, 0x3e, 0x20, 0x3c, 0x2e, 0x2e, 0x2e, 0x3e, 0x2e, 0x00 }; /* Replace <aa> <1> <...>. */
1844 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
1845 status = U_ZERO_ERROR;
1846 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
1847 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
1848 utext_openUTF8(&replText, str_1, -1, &status);
1849
1850 re = uregex_openC("x(.*?)x", 0, NULL, &status);
1851 TEST_ASSERT_SUCCESS(status);
1852
1853 /* Normal case, with match */
1854 uregex_setText(re, text1, -1, &status);
1855 result = uregex_replaceAllUText(re, &replText, NULL, &status);
1856 TEST_ASSERT_SUCCESS(status);
1857 TEST_ASSERT_UTEXT(str_Replaceaa1, result);
1858 utext_close(result);
1859
1860 /* No match. Text should copy to output with no changes. */
1861 uregex_setText(re, text2, -1, &status);
1862 result = uregex_replaceAllUText(re, &replText, NULL, &status);
1863 TEST_ASSERT_SUCCESS(status);
1864 TEST_ASSERT_UTEXT(str_Nomatchhere, result);
1865 utext_close(result);
1866
1867 uregex_close(re);
1868 utext_close(&replText);
1869 }
1870
1871
1872 /*
1873 * appendReplacement()
1874 */
1875 {
1876 UChar text[100];
1877 UChar repl[100];
1878 UChar buf[100];
1879 UChar *bufPtr;
1880 int32_t bufCap;
1881
1882 status = U_ZERO_ERROR;
1883 re = uregex_openC(".*", 0, 0, &status);
1884 TEST_ASSERT_SUCCESS(status);
1885
1886 u_uastrncpy(text, "whatever", sizeof(text)/2);
1887 u_uastrncpy(repl, "some other", sizeof(repl)/2);
1888 uregex_setText(re, text, -1, &status);
1889
1890 /* match covers whole target string */
1891 uregex_find(re, 0, &status);
1892 TEST_ASSERT_SUCCESS(status);
1893 bufPtr = buf;
1894 bufCap = sizeof(buf) / 2;
1895 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1896 TEST_ASSERT_SUCCESS(status);
1897 TEST_ASSERT_STRING("some other", buf, TRUE);
1898
1899 /* Match has \u \U escapes */
1900 uregex_find(re, 0, &status);
1901 TEST_ASSERT_SUCCESS(status);
1902 bufPtr = buf;
1903 bufCap = sizeof(buf) / 2;
1904 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2);
1905 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1906 TEST_ASSERT_SUCCESS(status);
1907 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE);
1908
1909 uregex_close(re);
1910 }
1911
1912
1913 /*
1914 * appendReplacement(), appendTail() checked in replaceFirst(), replaceAll().
1915 */
1916
1917 /*
1918 * splitUText()
1919 */
1920 {
1921 UChar textToSplit[80];
1922 UChar text2[80];
1923 UText *fields[10];
1924 int32_t numFields;
1925 int32_t i;
1926
1927 u_uastrncpy(textToSplit, "first : second: third", sizeof(textToSplit)/2);
1928 u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
1929
1930 status = U_ZERO_ERROR;
1931 re = uregex_openC(":", 0, NULL, &status);
1932
1933
1934 /* Simple split */
1935
1936 uregex_setText(re, textToSplit, -1, &status);
1937 TEST_ASSERT_SUCCESS(status);
1938
1939 /* The TEST_ASSERT_SUCCESS call above should change too... */
1940 if (U_SUCCESS(status)) {
1941 memset(fields, 0, sizeof(fields));
1942 numFields = uregex_splitUText(re, fields, 10, &status);
1943 TEST_ASSERT_SUCCESS(status);
1944
1945 /* The TEST_ASSERT_SUCCESS call above should change too... */
1946 if(U_SUCCESS(status)) {
1947 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* 'first ' */
1948 const char str_second[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00 }; /* ' second' */
1949 const char str_third[] = { 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* ' third' */
1950 TEST_ASSERT(numFields == 3);
1951 TEST_ASSERT_UTEXT(str_first, fields[0]);
1952 TEST_ASSERT_UTEXT(str_second, fields[1]);
1953 TEST_ASSERT_UTEXT(str_third, fields[2]);
1954 TEST_ASSERT(fields[3] == NULL);
1955 }
1956 for(i = 0; i < numFields; i++) {
1957 utext_close(fields[i]);
1958 }
1959 }
1960
1961 uregex_close(re);
1962
1963
1964 /* Split with too few output strings available */
1965 status = U_ZERO_ERROR;
1966 re = uregex_openC(":", 0, NULL, &status);
1967 uregex_setText(re, textToSplit, -1, &status);
1968 TEST_ASSERT_SUCCESS(status);
1969
1970 /* The TEST_ASSERT_SUCCESS call above should change too... */
1971 if(U_SUCCESS(status)) {
1972 fields[0] = NULL;
1973 fields[1] = NULL;
1974 fields[2] = &patternText;
1975 numFields = uregex_splitUText(re, fields, 2, &status);
1976 TEST_ASSERT_SUCCESS(status);
1977
1978 /* The TEST_ASSERT_SUCCESS call above should change too... */
1979 if(U_SUCCESS(status)) {
1980 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
1981 const char str_secondthird[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x3a, 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* second: third */
1982 TEST_ASSERT(numFields == 2);
1983 TEST_ASSERT_UTEXT(str_first, fields[0]);
1984 TEST_ASSERT_UTEXT(str_secondthird, fields[1]);
1985 TEST_ASSERT(fields[2] == &patternText);
1986 }
1987 for(i = 0; i < numFields; i++) {
1988 utext_close(fields[i]);
1989 }
1990 }
1991
1992 uregex_close(re);
1993 }
1994
1995 /* splitUText(), part 2. Patterns with capture groups. The capture group text
1996 * comes out as additional fields. */
1997 {
1998 UChar textToSplit[80];
1999 UText *fields[10];
2000 int32_t numFields;
2001 int32_t i;
2002
2003 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", sizeof(textToSplit)/2);
2004
2005 status = U_ZERO_ERROR;
2006 re = uregex_openC("<(.*?)>", 0, NULL, &status);
2007
2008 uregex_setText(re, textToSplit, -1, &status);
2009 TEST_ASSERT_SUCCESS(status);
2010
2011 /* The TEST_ASSERT_SUCCESS call above should change too... */
2012 if(U_SUCCESS(status)) {
2013 memset(fields, 0, sizeof(fields));
2014 numFields = uregex_splitUText(re, fields, 10, &status);
2015 TEST_ASSERT_SUCCESS(status);
2016
2017 /* The TEST_ASSERT_SUCCESS call above should change too... */
2018 if(U_SUCCESS(status)) {
2019 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
2020 const char str_taga[] = { 0x74, 0x61, 0x67, 0x2d, 0x61, 0x00 }; /* tag-a */
2021 const char str_second[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00 }; /* second */
2022 const char str_tagb[] = { 0x74, 0x61, 0x67, 0x2d, 0x62, 0x00 }; /* tag-b */
2023 const char str_third[] = { 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* third */
2024
2025 TEST_ASSERT(numFields == 5);
2026 TEST_ASSERT_UTEXT(str_first, fields[0]);
2027 TEST_ASSERT_UTEXT(str_taga, fields[1]);
2028 TEST_ASSERT_UTEXT(str_second, fields[2]);
2029 TEST_ASSERT_UTEXT(str_tagb, fields[3]);
2030 TEST_ASSERT_UTEXT(str_third, fields[4]);
2031 TEST_ASSERT(fields[5] == NULL);
2032 }
2033 for(i = 0; i < numFields; i++) {
2034 utext_close(fields[i]);
2035 }
2036 }
2037
2038 /* Split with too few output strings available (2) */
2039 status = U_ZERO_ERROR;
2040 fields[0] = NULL;
2041 fields[1] = NULL;
2042 fields[2] = &patternText;
2043 numFields = uregex_splitUText(re, fields, 2, &status);
2044 TEST_ASSERT_SUCCESS(status);
2045
2046 /* The TEST_ASSERT_SUCCESS call above should change too... */
2047 if(U_SUCCESS(status)) {
2048 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
2049 const char str_secondtagbthird[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x3c, 0x74, 0x61, 0x67, 0x2d, 0x62, 0x3e, 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* second<tag-b> third */
2050 TEST_ASSERT(numFields == 2);
2051 TEST_ASSERT_UTEXT(str_first, fields[0]);
2052 TEST_ASSERT_UTEXT(str_secondtagbthird, fields[1]);
2053 TEST_ASSERT(fields[2] == &patternText);
2054 }
2055 for(i = 0; i < numFields; i++) {
2056 utext_close(fields[i]);
2057 }
2058
2059
2060 /* Split with too few output strings available (3) */
2061 status = U_ZERO_ERROR;
2062 fields[0] = NULL;
2063 fields[1] = NULL;
2064 fields[2] = NULL;
2065 fields[3] = &patternText;
2066 numFields = uregex_splitUText(re, fields, 3, &status);
2067 TEST_ASSERT_SUCCESS(status);
2068
2069 /* The TEST_ASSERT_SUCCESS call above should change too... */
2070 if(U_SUCCESS(status)) {
2071 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
2072 const char str_taga[] = { 0x74, 0x61, 0x67, 0x2d, 0x61, 0x00 }; /* tag-a */
2073 const char str_secondtagbthird[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x3c, 0x74, 0x61, 0x67, 0x2d, 0x62, 0x3e, 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* second<tag-b> third */
2074 TEST_ASSERT(numFields == 3);
2075 TEST_ASSERT_UTEXT(str_first, fields[0]);
2076 TEST_ASSERT_UTEXT(str_taga, fields[1]);
2077 TEST_ASSERT_UTEXT(str_secondtagbthird, fields[2]);
2078 TEST_ASSERT(fields[3] == &patternText);
2079 }
2080 for(i = 0; i < numFields; i++) {
2081 utext_close(fields[i]);
2082 }
2083
2084 /* Split with just enough output strings available (5) */
2085 status = U_ZERO_ERROR;
2086 fields[0] = NULL;
2087 fields[1] = NULL;
2088 fields[2] = NULL;
2089 fields[3] = NULL;
2090 fields[4] = NULL;
2091 fields[5] = &patternText;
2092 numFields = uregex_splitUText(re, fields, 5, &status);
2093 TEST_ASSERT_SUCCESS(status);
2094
2095 /* The TEST_ASSERT_SUCCESS call above should change too... */
2096 if(U_SUCCESS(status)) {
2097 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
2098 const char str_taga[] = { 0x74, 0x61, 0x67, 0x2d, 0x61, 0x00 }; /* tag-a */
2099 const char str_second[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00 }; /* second */
2100 const char str_tagb[] = { 0x74, 0x61, 0x67, 0x2d, 0x62, 0x00 }; /* tag-b */
2101 const char str_third[] = { 0x20, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00 }; /* third */
2102
2103 TEST_ASSERT(numFields == 5);
2104 TEST_ASSERT_UTEXT(str_first, fields[0]);
2105 TEST_ASSERT_UTEXT(str_taga, fields[1]);
2106 TEST_ASSERT_UTEXT(str_second, fields[2]);
2107 TEST_ASSERT_UTEXT(str_tagb, fields[3]);
2108 TEST_ASSERT_UTEXT(str_third, fields[4]);
2109 TEST_ASSERT(fields[5] == &patternText);
2110 }
2111 for(i = 0; i < numFields; i++) {
2112 utext_close(fields[i]);
2113 }
2114
2115 /* Split, end of text is a field delimiter. */
2116 status = U_ZERO_ERROR;
2117 uregex_setText(re, textToSplit, strlen("first <tag-a> second<tag-b>"), &status);
2118 TEST_ASSERT_SUCCESS(status);
2119
2120 /* The TEST_ASSERT_SUCCESS call above should change too... */
2121 if(U_SUCCESS(status)) {
2122 memset(fields, 0, sizeof(fields));
2123 fields[9] = &patternText;
2124 numFields = uregex_splitUText(re, fields, 9, &status);
2125 TEST_ASSERT_SUCCESS(status);
2126
2127 /* The TEST_ASSERT_SUCCESS call above should change too... */
2128 if(U_SUCCESS(status)) {
2129 const char str_first[] = { 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x00 }; /* first */
2130 const char str_taga[] = { 0x74, 0x61, 0x67, 0x2d, 0x61, 0x00 }; /* tag-a */
2131 const char str_second[] = { 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00 }; /* second */
2132 const char str_tagb[] = { 0x74, 0x61, 0x67, 0x2d, 0x62, 0x00 }; /* tag-b */
2133
2134 TEST_ASSERT(numFields == 4);
2135 TEST_ASSERT_UTEXT(str_first, fields[0]);
2136 TEST_ASSERT_UTEXT(str_taga, fields[1]);
2137 TEST_ASSERT_UTEXT(str_second, fields[2]);
2138 TEST_ASSERT_UTEXT(str_tagb, fields[3]);
2139 TEST_ASSERT(fields[4] == NULL);
2140 TEST_ASSERT(fields[8] == NULL);
2141 TEST_ASSERT(fields[9] == &patternText);
2142 }
2143 for(i = 0; i < numFields; i++) {
2144 utext_close(fields[i]);
2145 }
2146 }
2147
2148 uregex_close(re);
2149 }
2150 utext_close(&patternText);
2151 }
2152
2153 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
2154