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