Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(87)

Side by Side Diff: source/test/cintltst/reapits.c

Issue 845603002: Update ICU to 54.1 step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@master
Patch Set: remove unusued directories Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « source/test/cintltst/nucnvtst.c ('k') | source/test/cintltst/sorttest.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /******************************************************************** 1 /********************************************************************
2 * COPYRIGHT: 2 * COPYRIGHT:
3 * Copyright (c) 2004-2013, International Business Machines Corporation and 3 * Copyright (c) 2004-2014, International Business Machines Corporation and
4 * others. All Rights Reserved. 4 * others. All Rights Reserved.
5 ********************************************************************/ 5 ********************************************************************/
6 /******************************************************************************* * 6 /******************************************************************************* *
7 * 7 *
8 * File reapits.c 8 * File reapits.c
9 * 9 *
10 ******************************************************************************** */ 10 ******************************************************************************** */
11 /*C API TEST FOR Regular Expressions */ 11 /*C API TEST FOR Regular Expressions */
12 /** 12 /**
13 * This is an API test for ICU regular expressions in C. It doesn't test very many cases, and doesn't 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 verifie s that it 14 * try to test the full functionality. It just calls each function and verifie s that it
15 * works on a basic level. 15 * works on a basic level.
16 * 16 *
17 * More complete testing of regular expression functionality is done with the C ++ tests. 17 * More complete testing of regular expression functionality is done with the C ++ tests.
18 **/ 18 **/
19 19
20 #include "unicode/utypes.h" 20 #include "unicode/utypes.h"
21 21
22 #if !UCONFIG_NO_REGULAR_EXPRESSIONS 22 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
23 23
24 #include <stdlib.h> 24 #include <stdlib.h>
25 #include <string.h> 25 #include <string.h>
26 #include "unicode/uloc.h" 26 #include "unicode/uloc.h"
27 #include "unicode/uregex.h" 27 #include "unicode/uregex.h"
28 #include "unicode/ustring.h" 28 #include "unicode/ustring.h"
29 #include "unicode/utext.h" 29 #include "unicode/utext.h"
30 #include "cintltst.h" 30 #include "cintltst.h"
31 #include "cmemory.h"
31 32
32 #define TEST_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \ 33 #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 log_data_err("Failure at file %s:%d - error = %s (Are you missing data?)\n", __F ILE__, __LINE__, u_errorName(status));}}
34 35
35 #define TEST_ASSERT(expr) {if ((expr)==FALSE) { \ 36 #define TEST_ASSERT(expr) {if ((expr)==FALSE) { \
36 log_data_err("Test Failure at file %s, line %d (Are you missing data?)\n", __FIL E__, __LINE__);}} 37 log_err("Test Failure at file %s:%d - ASSERT(%s) failed.\n", __FILE__, __LINE__, #expr);}}
37 38
38 /* 39 /*
39 * TEST_SETUP and TEST_TEARDOWN 40 * TEST_SETUP and TEST_TEARDOWN
40 * macros to handle the boilerplate around setting up regex test cases. 41 * macros to handle the boilerplate around setting up regex test cases.
41 * parameteres to setup: 42 * parameteres to setup:
42 * pattern: The regex pattern, a (char *) null terminated C str ing. 43 * pattern: The regex pattern, a (char *) null terminated C str ing.
43 * testString: The string data, also a (char *) C string. 44 * testString: The string data, also a (char *) C string.
44 * flags: Regex flags to set when compiling the pattern 45 * flags: Regex flags to set when compiling the pattern
45 * 46 *
46 * Put arbitrary test code between SETUP and TEARDOWN. 47 * Put arbitrary test code between SETUP and TEARDOWN.
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
151 } 152 }
152 153
153 154
154 155
155 156
156 static void TestRegexCAPI(void); 157 static void TestRegexCAPI(void);
157 static void TestBug4315(void); 158 static void TestBug4315(void);
158 static void TestUTextAPI(void); 159 static void TestUTextAPI(void);
159 static void TestRefreshInput(void); 160 static void TestRefreshInput(void);
160 static void TestBug8421(void); 161 static void TestBug8421(void);
162 static void TestBug10815(void);
161 163
162 void addURegexTest(TestNode** root); 164 void addURegexTest(TestNode** root);
163 165
164 void addURegexTest(TestNode** root) 166 void addURegexTest(TestNode** root)
165 { 167 {
166 addTest(root, &TestRegexCAPI, "regex/TestRegexCAPI"); 168 addTest(root, &TestRegexCAPI, "regex/TestRegexCAPI");
167 addTest(root, &TestBug4315, "regex/TestBug4315"); 169 addTest(root, &TestBug4315, "regex/TestBug4315");
168 addTest(root, &TestUTextAPI, "regex/TestUTextAPI"); 170 addTest(root, &TestUTextAPI, "regex/TestUTextAPI");
169 addTest(root, &TestRefreshInput, "regex/TestRefreshInput"); 171 addTest(root, &TestRefreshInput, "regex/TestRefreshInput");
170 addTest(root, &TestBug8421, "regex/TestBug8421"); 172 addTest(root, &TestBug8421, "regex/TestBug8421");
173 addTest(root, &TestBug10815, "regex/TestBug10815");
171 } 174 }
172 175
173 /* 176 /*
174 * Call back function and context struct used for testing 177 * Call back function and context struct used for testing
175 * regular expression user callbacks. This test is mostly the same as 178 * regular expression user callbacks. This test is mostly the same as
176 * the corresponding C++ test in intltest. 179 * the corresponding C++ test in intltest.
177 */ 180 */
178 typedef struct callBackContext { 181 typedef struct callBackContext {
179 int32_t maxCalls; 182 int32_t maxCalls;
180 int32_t numCalls; 183 int32_t numCalls;
(...skipping 16 matching lines...) Expand all
197 */ 200 */
198 static void TestRegexCAPI(void) { 201 static void TestRegexCAPI(void) {
199 UErrorCode status = U_ZERO_ERROR; 202 UErrorCode status = U_ZERO_ERROR;
200 URegularExpression *re; 203 URegularExpression *re;
201 UChar pat[200]; 204 UChar pat[200];
202 UChar *minus1; 205 UChar *minus1;
203 206
204 memset(&minus1, -1, sizeof(minus1)); 207 memset(&minus1, -1, sizeof(minus1));
205 208
206 /* Mimimalist open/close */ 209 /* Mimimalist open/close */
207 u_uastrncpy(pat, "abc*", sizeof(pat)/2); 210 u_uastrncpy(pat, "abc*", UPRV_LENGTHOF(pat));
208 re = uregex_open(pat, -1, 0, 0, &status); 211 re = uregex_open(pat, -1, 0, 0, &status);
209 if (U_FAILURE(status)) { 212 if (U_FAILURE(status)) {
210 log_data_err("Failed to open regular expression, %s:%d, error is \"%s\" (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(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));
211 return; 214 return;
212 } 215 }
213 uregex_close(re); 216 uregex_close(re);
214 217
215 /* Open with all flag values set */ 218 /* Open with all flag values set */
216 status = U_ZERO_ERROR; 219 status = U_ZERO_ERROR;
217 re = uregex_open(pat, -1, 220 re = uregex_open(pat, -1,
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
249 const UChar *p; 252 const UChar *p;
250 int32_t len; 253 int32_t len;
251 status = U_ZERO_ERROR; 254 status = U_ZERO_ERROR;
252 re = uregex_openC("abc*", 0, 0, &status); 255 re = uregex_openC("abc*", 0, 0, &status);
253 TEST_ASSERT_SUCCESS(status); 256 TEST_ASSERT_SUCCESS(status);
254 p = uregex_pattern(re, &len, &status); 257 p = uregex_pattern(re, &len, &status);
255 TEST_ASSERT_SUCCESS(status); 258 TEST_ASSERT_SUCCESS(status);
256 259
257 /* The TEST_ASSERT_SUCCESS above should change too... */ 260 /* The TEST_ASSERT_SUCCESS above should change too... */
258 if(U_SUCCESS(status)) { 261 if(U_SUCCESS(status)) {
259 u_uastrncpy(pat, "abc*", sizeof(pat)/2); 262 u_uastrncpy(pat, "abc*", UPRV_LENGTHOF(pat));
260 TEST_ASSERT(u_strcmp(pat, p) == 0); 263 TEST_ASSERT(u_strcmp(pat, p) == 0);
261 TEST_ASSERT(len==(int32_t)strlen("abc*")); 264 TEST_ASSERT(len==(int32_t)strlen("abc*"));
262 } 265 }
263 266
264 uregex_close(re); 267 uregex_close(re);
265 268
266 /* TODO: Open with ParseError parameter */ 269 /* TODO: Open with ParseError parameter */
267 } 270 }
268 271
269 /* 272 /*
(...skipping 19 matching lines...) Expand all
289 clone2 = uregex_clone(re, &status); 292 clone2 = uregex_clone(re, &status);
290 TEST_ASSERT_SUCCESS(status); 293 TEST_ASSERT_SUCCESS(status);
291 TEST_ASSERT(clone2 != NULL); 294 TEST_ASSERT(clone2 != NULL);
292 uregex_close(re); 295 uregex_close(re);
293 296
294 status = U_ZERO_ERROR; 297 status = U_ZERO_ERROR;
295 clone3 = uregex_clone(clone2, &status); 298 clone3 = uregex_clone(clone2, &status);
296 TEST_ASSERT_SUCCESS(status); 299 TEST_ASSERT_SUCCESS(status);
297 TEST_ASSERT(clone3 != NULL); 300 TEST_ASSERT(clone3 != NULL);
298 301
299 u_uastrncpy(testString1, "abcccd", sizeof(pat)/2); 302 u_uastrncpy(testString1, "abcccd", UPRV_LENGTHOF(pat));
300 u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2); 303 u_uastrncpy(testString2, "xxxabcccd", UPRV_LENGTHOF(pat));
301 304
302 status = U_ZERO_ERROR; 305 status = U_ZERO_ERROR;
303 uregex_setText(clone1, testString1, -1, &status); 306 uregex_setText(clone1, testString1, -1, &status);
304 TEST_ASSERT_SUCCESS(status); 307 TEST_ASSERT_SUCCESS(status);
305 result = uregex_lookingAt(clone1, 0, &status); 308 result = uregex_lookingAt(clone1, 0, &status);
306 TEST_ASSERT_SUCCESS(status); 309 TEST_ASSERT_SUCCESS(status);
307 TEST_ASSERT(result==TRUE); 310 TEST_ASSERT(result==TRUE);
308 311
309 status = U_ZERO_ERROR; 312 status = U_ZERO_ERROR;
310 uregex_setText(clone2, testString2, -1, &status); 313 uregex_setText(clone2, testString2, -1, &status);
(...skipping 10 matching lines...) Expand all
321 uregex_close(clone3); 324 uregex_close(clone3);
322 325
323 } 326 }
324 327
325 /* 328 /*
326 * pattern() 329 * pattern()
327 */ 330 */
328 { 331 {
329 const UChar *resultPat; 332 const UChar *resultPat;
330 int32_t resultLen; 333 int32_t resultLen;
331 u_uastrncpy(pat, "hello", sizeof(pat)/2); 334 u_uastrncpy(pat, "hello", UPRV_LENGTHOF(pat));
332 status = U_ZERO_ERROR; 335 status = U_ZERO_ERROR;
333 re = uregex_open(pat, -1, 0, NULL, &status); 336 re = uregex_open(pat, -1, 0, NULL, &status);
334 resultPat = uregex_pattern(re, &resultLen, &status); 337 resultPat = uregex_pattern(re, &resultLen, &status);
335 TEST_ASSERT_SUCCESS(status); 338 TEST_ASSERT_SUCCESS(status);
336 339
337 /* The TEST_ASSERT_SUCCESS above should change too... */ 340 /* The TEST_ASSERT_SUCCESS above should change too... */
338 if (U_SUCCESS(status)) { 341 if (U_SUCCESS(status)) {
339 TEST_ASSERT(resultLen == -1); 342 TEST_ASSERT(resultLen == -1);
340 TEST_ASSERT(u_strcmp(resultPat, pat) == 0); 343 TEST_ASSERT(u_strcmp(resultPat, pat) == 0);
341 } 344 }
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
387 } 390 }
388 391
389 /* 392 /*
390 * setText() and lookingAt() 393 * setText() and lookingAt()
391 */ 394 */
392 { 395 {
393 UChar text1[50]; 396 UChar text1[50];
394 UChar text2[50]; 397 UChar text2[50];
395 UBool result; 398 UBool result;
396 399
397 u_uastrncpy(text1, "abcccd", sizeof(text1)/2); 400 u_uastrncpy(text1, "abcccd", UPRV_LENGTHOF(text1));
398 u_uastrncpy(text2, "abcccxd", sizeof(text2)/2); 401 u_uastrncpy(text2, "abcccxd", UPRV_LENGTHOF(text2));
399 status = U_ZERO_ERROR; 402 status = U_ZERO_ERROR;
400 u_uastrncpy(pat, "abc*d", sizeof(pat)/2); 403 u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
401 re = uregex_open(pat, -1, 0, NULL, &status); 404 re = uregex_open(pat, -1, 0, NULL, &status);
402 TEST_ASSERT_SUCCESS(status); 405 TEST_ASSERT_SUCCESS(status);
403 406
404 /* Operation before doing a setText should fail... */ 407 /* Operation before doing a setText should fail... */
405 status = U_ZERO_ERROR; 408 status = U_ZERO_ERROR;
406 uregex_lookingAt(re, 0, &status); 409 uregex_lookingAt(re, 0, &status);
407 TEST_ASSERT( status== U_REGEX_INVALID_STATE); 410 TEST_ASSERT( status== U_REGEX_INVALID_STATE);
408 411
409 status = U_ZERO_ERROR; 412 status = U_ZERO_ERROR;
410 uregex_setText(re, text1, -1, &status); 413 uregex_setText(re, text1, -1, &status);
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
442 445
443 /* 446 /*
444 * getText() 447 * getText()
445 */ 448 */
446 { 449 {
447 UChar text1[50]; 450 UChar text1[50];
448 UChar text2[50]; 451 UChar text2[50];
449 const UChar *result; 452 const UChar *result;
450 int32_t textLength; 453 int32_t textLength;
451 454
452 u_uastrncpy(text1, "abcccd", sizeof(text1)/2); 455 u_uastrncpy(text1, "abcccd", UPRV_LENGTHOF(text1));
453 u_uastrncpy(text2, "abcccxd", sizeof(text2)/2); 456 u_uastrncpy(text2, "abcccxd", UPRV_LENGTHOF(text2));
454 status = U_ZERO_ERROR; 457 status = U_ZERO_ERROR;
455 u_uastrncpy(pat, "abc*d", sizeof(pat)/2); 458 u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
456 re = uregex_open(pat, -1, 0, NULL, &status); 459 re = uregex_open(pat, -1, 0, NULL, &status);
457 460
458 uregex_setText(re, text1, -1, &status); 461 uregex_setText(re, text1, -1, &status);
459 result = uregex_getText(re, &textLength, &status); 462 result = uregex_getText(re, &textLength, &status);
460 TEST_ASSERT(result == text1); 463 TEST_ASSERT(result == text1);
461 TEST_ASSERT(textLength == -1); 464 TEST_ASSERT(textLength == -1);
462 TEST_ASSERT_SUCCESS(status); 465 TEST_ASSERT_SUCCESS(status);
463 466
464 status = U_ZERO_ERROR; 467 status = U_ZERO_ERROR;
465 uregex_setText(re, text2, 7, &status); 468 uregex_setText(re, text2, 7, &status);
(...skipping 13 matching lines...) Expand all
479 482
480 /* 483 /*
481 * matches() 484 * matches()
482 */ 485 */
483 { 486 {
484 UChar text1[50]; 487 UChar text1[50];
485 UBool result; 488 UBool result;
486 int len; 489 int len;
487 UChar nullString[] = {0,0,0}; 490 UChar nullString[] = {0,0,0};
488 491
489 u_uastrncpy(text1, "abcccde", sizeof(text1)/2); 492 u_uastrncpy(text1, "abcccde", UPRV_LENGTHOF(text1));
490 status = U_ZERO_ERROR; 493 status = U_ZERO_ERROR;
491 u_uastrncpy(pat, "abc*d", sizeof(pat)/2); 494 u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
492 re = uregex_open(pat, -1, 0, NULL, &status); 495 re = uregex_open(pat, -1, 0, NULL, &status);
493 496
494 uregex_setText(re, text1, -1, &status); 497 uregex_setText(re, text1, -1, &status);
495 result = uregex_matches(re, 0, &status); 498 result = uregex_matches(re, 0, &status);
496 TEST_ASSERT(result == FALSE); 499 TEST_ASSERT(result == FALSE);
497 TEST_ASSERT_SUCCESS(status); 500 TEST_ASSERT_SUCCESS(status);
498 501
499 status = U_ZERO_ERROR; 502 status = U_ZERO_ERROR;
500 uregex_setText(re, text1, 6, &status); 503 uregex_setText(re, text1, 6, &status);
501 result = uregex_matches(re, 0, &status); 504 result = uregex_matches(re, 0, &status);
(...skipping 29 matching lines...) Expand all
531 * lookingAt() Used in setText test. 534 * lookingAt() Used in setText test.
532 */ 535 */
533 536
534 537
535 /* 538 /*
536 * find(), findNext, start, end, reset 539 * find(), findNext, start, end, reset
537 */ 540 */
538 { 541 {
539 UChar text1[50]; 542 UChar text1[50];
540 UBool result; 543 UBool result;
541 u_uastrncpy(text1, "012rx5rx890rxrx...", sizeof(text1)/2); 544 u_uastrncpy(text1, "012rx5rx890rxrx...", UPRV_LENGTHOF(text1));
542 status = U_ZERO_ERROR; 545 status = U_ZERO_ERROR;
543 re = uregex_openC("rx", 0, NULL, &status); 546 re = uregex_openC("rx", 0, NULL, &status);
544 547
545 uregex_setText(re, text1, -1, &status); 548 uregex_setText(re, text1, -1, &status);
546 result = uregex_find(re, 0, &status); 549 result = uregex_find(re, 0, &status);
547 TEST_ASSERT(result == TRUE); 550 TEST_ASSERT(result == TRUE);
548 TEST_ASSERT(uregex_start(re, 0, &status) == 3); 551 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
549 TEST_ASSERT(uregex_end(re, 0, &status) == 5); 552 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
550 TEST_ASSERT_SUCCESS(status); 553 TEST_ASSERT_SUCCESS(status);
551 554
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after
614 617
615 618
616 /* 619 /*
617 * group() 620 * group()
618 */ 621 */
619 { 622 {
620 UChar text1[80]; 623 UChar text1[80];
621 UChar buf[80]; 624 UChar buf[80];
622 UBool result; 625 UBool result;
623 int32_t resultSz; 626 int32_t resultSz;
624 u_uastrncpy(text1, "noise abc interior def, and this is off the end", s izeof(text1)/2); 627 u_uastrncpy(text1, "noise abc interior def, and this is off the end", U PRV_LENGTHOF(text1));
625 628
626 status = U_ZERO_ERROR; 629 status = U_ZERO_ERROR;
627 re = uregex_openC("abc(.*?)def", 0, NULL, &status); 630 re = uregex_openC("abc(.*?)def", 0, NULL, &status);
628 TEST_ASSERT_SUCCESS(status); 631 TEST_ASSERT_SUCCESS(status);
629 632
630 633
631 uregex_setText(re, text1, -1, &status); 634 uregex_setText(re, text1, -1, &status);
632 result = uregex_find(re, 0, &status); 635 result = uregex_find(re, 0, &status);
633 TEST_ASSERT(result==TRUE); 636 TEST_ASSERT(result==TRUE);
634 637
635 /* Capture Group 0, the full match. Should succeed. */ 638 /* Capture Group 0, the full match. Should succeed. */
636 status = U_ZERO_ERROR; 639 status = U_ZERO_ERROR;
637 resultSz = uregex_group(re, 0, buf, sizeof(buf)/2, &status); 640 resultSz = uregex_group(re, 0, buf, UPRV_LENGTHOF(buf), &status);
638 TEST_ASSERT_SUCCESS(status); 641 TEST_ASSERT_SUCCESS(status);
639 TEST_ASSERT_STRING("abc interior def", buf, TRUE); 642 TEST_ASSERT_STRING("abc interior def", buf, TRUE);
640 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def")); 643 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
641 644
642 /* Capture group #1. Should succeed. */ 645 /* Capture group #1. Should succeed. */
643 status = U_ZERO_ERROR; 646 status = U_ZERO_ERROR;
644 resultSz = uregex_group(re, 1, buf, sizeof(buf)/2, &status); 647 resultSz = uregex_group(re, 1, buf, UPRV_LENGTHOF(buf), &status);
645 TEST_ASSERT_SUCCESS(status); 648 TEST_ASSERT_SUCCESS(status);
646 TEST_ASSERT_STRING(" interior ", buf, TRUE); 649 TEST_ASSERT_STRING(" interior ", buf, TRUE);
647 TEST_ASSERT(resultSz == (int32_t)strlen(" interior ")); 650 TEST_ASSERT(resultSz == (int32_t)strlen(" interior "));
648 651
649 /* Capture group out of range. Error. */ 652 /* Capture group out of range. Error. */
650 status = U_ZERO_ERROR; 653 status = U_ZERO_ERROR;
651 uregex_group(re, 2, buf, sizeof(buf)/2, &status); 654 uregex_group(re, 2, buf, UPRV_LENGTHOF(buf), &status);
652 TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 655 TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
653 656
654 /* NULL buffer, pure pre-flight */ 657 /* NULL buffer, pure pre-flight */
655 status = U_ZERO_ERROR; 658 status = U_ZERO_ERROR;
656 resultSz = uregex_group(re, 0, NULL, 0, &status); 659 resultSz = uregex_group(re, 0, NULL, 0, &status);
657 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR); 660 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
658 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def")); 661 TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
659 662
660 /* Too small buffer, truncated string */ 663 /* Too small buffer, truncated string */
661 status = U_ZERO_ERROR; 664 status = U_ZERO_ERROR;
(...skipping 23 matching lines...) Expand all
685 688
686 /* SetRegion(), getRegion() do something */ 689 /* SetRegion(), getRegion() do something */
687 TEST_SETUP(".*", "0123456789ABCDEF", 0) 690 TEST_SETUP(".*", "0123456789ABCDEF", 0)
688 UChar resultString[40]; 691 UChar resultString[40];
689 TEST_ASSERT(uregex_regionStart(re, &status) == 0); 692 TEST_ASSERT(uregex_regionStart(re, &status) == 0);
690 TEST_ASSERT(uregex_regionEnd(re, &status) == 16); 693 TEST_ASSERT(uregex_regionEnd(re, &status) == 16);
691 uregex_setRegion(re, 3, 6, &status); 694 uregex_setRegion(re, 3, 6, &status);
692 TEST_ASSERT(uregex_regionStart(re, &status) == 3); 695 TEST_ASSERT(uregex_regionStart(re, &status) == 3);
693 TEST_ASSERT(uregex_regionEnd(re, &status) == 6); 696 TEST_ASSERT(uregex_regionEnd(re, &status) == 6);
694 TEST_ASSERT(uregex_findNext(re, &status)); 697 TEST_ASSERT(uregex_findNext(re, &status));
695 TEST_ASSERT(uregex_group(re, 0, resultString, sizeof(resultString)/2, &s tatus) == 3) 698 TEST_ASSERT(uregex_group(re, 0, resultString, UPRV_LENGTHOF(resultString ), &status) == 3)
696 TEST_ASSERT_STRING("345", resultString, TRUE); 699 TEST_ASSERT_STRING("345", resultString, TRUE);
697 TEST_TEARDOWN; 700 TEST_TEARDOWN;
698 701
699 /* find(start=-1) uses regions */ 702 /* find(start=-1) uses regions */
700 TEST_SETUP(".*", "0123456789ABCDEF", 0); 703 TEST_SETUP(".*", "0123456789ABCDEF", 0);
701 uregex_setRegion(re, 4, 6, &status); 704 uregex_setRegion(re, 4, 6, &status);
702 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE); 705 TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
703 TEST_ASSERT(uregex_start(re, 0, &status) == 4); 706 TEST_ASSERT(uregex_start(re, 0, &status) == 4);
704 TEST_ASSERT(uregex_end(re, 0, &status) == 6); 707 TEST_ASSERT(uregex_end(re, 0, &status) == 6);
705 TEST_TEARDOWN; 708 TEST_TEARDOWN;
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after
809 812
810 /* 813 /*
811 * replaceFirst() 814 * replaceFirst()
812 */ 815 */
813 { 816 {
814 UChar text1[80]; 817 UChar text1[80];
815 UChar text2[80]; 818 UChar text2[80];
816 UChar replText[80]; 819 UChar replText[80];
817 UChar buf[80]; 820 UChar buf[80];
818 int32_t resultSz; 821 int32_t resultSz;
819 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 822 u_uastrncpy(text1, "Replace xaax x1x x...x.", UPRV_LENGTHOF(text1));
820 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 823 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
821 u_uastrncpy(replText, "<$1>", sizeof(replText)/2); 824 u_uastrncpy(replText, "<$1>", UPRV_LENGTHOF(replText));
822 825
823 status = U_ZERO_ERROR; 826 status = U_ZERO_ERROR;
824 re = uregex_openC("x(.*?)x", 0, NULL, &status); 827 re = uregex_openC("x(.*?)x", 0, NULL, &status);
825 TEST_ASSERT_SUCCESS(status); 828 TEST_ASSERT_SUCCESS(status);
826 829
827 /* Normal case, with match */ 830 /* Normal case, with match */
828 uregex_setText(re, text1, -1, &status); 831 uregex_setText(re, text1, -1, &status);
829 resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &st atus); 832 resultSz = uregex_replaceFirst(re, replText, -1, buf, UPRV_LENGTHOF(buf) , &status);
830 TEST_ASSERT_SUCCESS(status); 833 TEST_ASSERT_SUCCESS(status);
831 TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, TRUE); 834 TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, TRUE);
832 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x.")); 835 TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
833 836
834 /* No match. Text should copy to output with no changes. */ 837 /* No match. Text should copy to output with no changes. */
835 status = U_ZERO_ERROR; 838 status = U_ZERO_ERROR;
836 uregex_setText(re, text2, -1, &status); 839 uregex_setText(re, text2, -1, &status);
837 resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &st atus); 840 resultSz = uregex_replaceFirst(re, replText, -1, buf, UPRV_LENGTHOF(buf) , &status);
838 TEST_ASSERT_SUCCESS(status); 841 TEST_ASSERT_SUCCESS(status);
839 TEST_ASSERT_STRING("No match here.", buf, TRUE); 842 TEST_ASSERT_STRING("No match here.", buf, TRUE);
840 TEST_ASSERT(resultSz == (int32_t)strlen("No match here.")); 843 TEST_ASSERT(resultSz == (int32_t)strlen("No match here."));
841 844
842 /* Match, output just fills buffer, no termination warning. */ 845 /* Match, output just fills buffer, no termination warning. */
843 status = U_ZERO_ERROR; 846 status = U_ZERO_ERROR;
844 uregex_setText(re, text1, -1, &status); 847 uregex_setText(re, text1, -1, &status);
845 memset(buf, -1, sizeof(buf)); 848 memset(buf, -1, sizeof(buf));
846 resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <a a> x1x x...x."), &status); 849 resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <a a> x1x x...x."), &status);
847 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING); 850 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
889 UChar replText2[80]; /* "<<$1>>" */ 892 UChar replText2[80]; /* "<<$1>>" */
890 const char * pattern = "x(.*?)x"; 893 const char * pattern = "x(.*?)x";
891 const char * expectedResult = "Replace <aa> <1> <...>."; 894 const char * expectedResult = "Replace <aa> <1> <...>.";
892 const char * expectedResult2 = "Replace <<aa>> <<1>> <<...>>."; 895 const char * expectedResult2 = "Replace <<aa>> <<1>> <<...>>.";
893 UChar buf[80]; 896 UChar buf[80];
894 int32_t resultSize; 897 int32_t resultSize;
895 int32_t expectedResultSize; 898 int32_t expectedResultSize;
896 int32_t expectedResultSize2; 899 int32_t expectedResultSize2;
897 int32_t i; 900 int32_t i;
898 901
899 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 902 u_uastrncpy(text1, "Replace xaax x1x x...x.", UPRV_LENGTHOF(text1));
900 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 903 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
901 u_uastrncpy(replText, "<$1>", sizeof(replText)/2); 904 u_uastrncpy(replText, "<$1>", UPRV_LENGTHOF(replText));
902 u_uastrncpy(replText2, "<<$1>>", sizeof(replText2)/2); 905 u_uastrncpy(replText2, "<<$1>>", UPRV_LENGTHOF(replText2));
903 expectedResultSize = strlen(expectedResult); 906 expectedResultSize = strlen(expectedResult);
904 expectedResultSize2 = strlen(expectedResult2); 907 expectedResultSize2 = strlen(expectedResult2);
905 908
906 status = U_ZERO_ERROR; 909 status = U_ZERO_ERROR;
907 re = uregex_openC(pattern, 0, NULL, &status); 910 re = uregex_openC(pattern, 0, NULL, &status);
908 TEST_ASSERT_SUCCESS(status); 911 TEST_ASSERT_SUCCESS(status);
909 912
910 /* Normal case, with match */ 913 /* Normal case, with match */
911 uregex_setText(re, text1, -1, &status); 914 uregex_setText(re, text1, -1, &status);
912 resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &st atus); 915 resultSize = uregex_replaceAll(re, replText, -1, buf, UPRV_LENGTHOF(buf) , &status);
913 TEST_ASSERT_SUCCESS(status); 916 TEST_ASSERT_SUCCESS(status);
914 TEST_ASSERT_STRING(expectedResult, buf, TRUE); 917 TEST_ASSERT_STRING(expectedResult, buf, TRUE);
915 TEST_ASSERT(resultSize == expectedResultSize); 918 TEST_ASSERT(resultSize == expectedResultSize);
916 919
917 /* No match. Text should copy to output with no changes. */ 920 /* No match. Text should copy to output with no changes. */
918 status = U_ZERO_ERROR; 921 status = U_ZERO_ERROR;
919 uregex_setText(re, text2, -1, &status); 922 uregex_setText(re, text2, -1, &status);
920 resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &st atus); 923 resultSize = uregex_replaceAll(re, replText, -1, buf, UPRV_LENGTHOF(buf) , &status);
921 TEST_ASSERT_SUCCESS(status); 924 TEST_ASSERT_SUCCESS(status);
922 TEST_ASSERT_STRING("No match here.", buf, TRUE); 925 TEST_ASSERT_STRING("No match here.", buf, TRUE);
923 TEST_ASSERT(resultSize == u_strlen(text2)); 926 TEST_ASSERT(resultSize == u_strlen(text2));
924 927
925 /* Match, output just fills buffer, no termination warning. */ 928 /* Match, output just fills buffer, no termination warning. */
926 status = U_ZERO_ERROR; 929 status = U_ZERO_ERROR;
927 uregex_setText(re, text1, -1, &status); 930 uregex_setText(re, text1, -1, &status);
928 memset(buf, -1, sizeof(buf)); 931 memset(buf, -1, sizeof(buf));
929 resultSize = uregex_replaceAll(re, replText, -1, buf, expectedResultSize , &status); 932 resultSize = uregex_replaceAll(re, replText, -1, buf, expectedResultSize , &status);
930 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING); 933 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
994 UChar repl[100]; 997 UChar repl[100];
995 UChar buf[100]; 998 UChar buf[100];
996 UChar *bufPtr; 999 UChar *bufPtr;
997 int32_t bufCap; 1000 int32_t bufCap;
998 1001
999 1002
1000 status = U_ZERO_ERROR; 1003 status = U_ZERO_ERROR;
1001 re = uregex_openC(".*", 0, 0, &status); 1004 re = uregex_openC(".*", 0, 0, &status);
1002 TEST_ASSERT_SUCCESS(status); 1005 TEST_ASSERT_SUCCESS(status);
1003 1006
1004 u_uastrncpy(text, "whatever", sizeof(text)/2); 1007 u_uastrncpy(text, "whatever", UPRV_LENGTHOF(text));
1005 u_uastrncpy(repl, "some other", sizeof(repl)/2); 1008 u_uastrncpy(repl, "some other", UPRV_LENGTHOF(repl));
1006 uregex_setText(re, text, -1, &status); 1009 uregex_setText(re, text, -1, &status);
1007 1010
1008 /* match covers whole target string */ 1011 /* match covers whole target string */
1009 uregex_find(re, 0, &status); 1012 uregex_find(re, 0, &status);
1010 TEST_ASSERT_SUCCESS(status); 1013 TEST_ASSERT_SUCCESS(status);
1011 bufPtr = buf; 1014 bufPtr = buf;
1012 bufCap = sizeof(buf) / 2; 1015 bufCap = UPRV_LENGTHOF(buf);
1013 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status); 1016 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1014 TEST_ASSERT_SUCCESS(status); 1017 TEST_ASSERT_SUCCESS(status);
1015 TEST_ASSERT_STRING("some other", buf, TRUE); 1018 TEST_ASSERT_STRING("some other", buf, TRUE);
1016 1019
1017 /* Match has \u \U escapes */ 1020 /* Match has \u \U escapes */
1018 uregex_find(re, 0, &status); 1021 uregex_find(re, 0, &status);
1019 TEST_ASSERT_SUCCESS(status); 1022 TEST_ASSERT_SUCCESS(status);
1020 bufPtr = buf; 1023 bufPtr = buf;
1021 bufCap = sizeof(buf) / 2; 1024 bufCap = UPRV_LENGTHOF(buf);
1022 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2); 1025 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", UPRV_LENGTHOF(re pl));
1023 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status); 1026 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1024 TEST_ASSERT_SUCCESS(status); 1027 TEST_ASSERT_SUCCESS(status);
1025 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE); 1028 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE);
1026 1029
1027 /* Bug 6813, parameter check of NULL destCapacity; crashed before fix. * / 1030 /* Bug 6813, parameter check of NULL destCapacity; crashed before fix. * /
1028 status = U_ZERO_ERROR; 1031 status = U_ZERO_ERROR;
1029 uregex_find(re, 0, &status); 1032 uregex_find(re, 0, &status);
1030 TEST_ASSERT_SUCCESS(status); 1033 TEST_ASSERT_SUCCESS(status);
1031 bufPtr = buf; 1034 bufPtr = buf;
1032 status = U_BUFFER_OVERFLOW_ERROR; 1035 status = U_BUFFER_OVERFLOW_ERROR;
(...skipping 14 matching lines...) Expand all
1047 { 1050 {
1048 UChar textToSplit[80]; 1051 UChar textToSplit[80];
1049 UChar text2[80]; 1052 UChar text2[80];
1050 UChar buf[200]; 1053 UChar buf[200];
1051 UChar *fields[10]; 1054 UChar *fields[10];
1052 int32_t numFields; 1055 int32_t numFields;
1053 int32_t requiredCapacity; 1056 int32_t requiredCapacity;
1054 int32_t spaceNeeded; 1057 int32_t spaceNeeded;
1055 int32_t sz; 1058 int32_t sz;
1056 1059
1057 u_uastrncpy(textToSplit, "first : second: third", sizeof(textToSplit)/ 2); 1060 u_uastrncpy(textToSplit, "first : second: third", UPRV_LENGTHOF(textTo Split));
1058 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 1061 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
1059 1062
1060 status = U_ZERO_ERROR; 1063 status = U_ZERO_ERROR;
1061 re = uregex_openC(":", 0, NULL, &status); 1064 re = uregex_openC(":", 0, NULL, &status);
1062 1065
1063 1066
1064 /* Simple split */ 1067 /* Simple split */
1065 1068
1066 uregex_setText(re, textToSplit, -1, &status); 1069 uregex_setText(re, textToSplit, -1, &status);
1067 TEST_ASSERT_SUCCESS(status); 1070 TEST_ASSERT_SUCCESS(status);
1068 1071
1069 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1072 /* The TEST_ASSERT_SUCCESS call above should change too... */
1070 if (U_SUCCESS(status)) { 1073 if (U_SUCCESS(status)) {
1071 memset(fields, -1, sizeof(fields)); 1074 memset(fields, -1, sizeof(fields));
1072 numFields = 1075 numFields =
1073 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status); 1076 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fie lds, 10, &status);
1074 TEST_ASSERT_SUCCESS(status); 1077 TEST_ASSERT_SUCCESS(status);
1075 1078
1076 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1079 /* The TEST_ASSERT_SUCCESS call above should change too... */
1077 if(U_SUCCESS(status)) { 1080 if(U_SUCCESS(status)) {
1078 TEST_ASSERT(numFields == 3); 1081 TEST_ASSERT(numFields == 3);
1079 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1082 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1080 TEST_ASSERT_STRING(" second", fields[1], TRUE); 1083 TEST_ASSERT_STRING(" second", fields[1], TRUE);
1081 TEST_ASSERT_STRING(" third", fields[2], TRUE); 1084 TEST_ASSERT_STRING(" third", fields[2], TRUE);
1082 TEST_ASSERT(fields[3] == NULL); 1085 TEST_ASSERT(fields[3] == NULL);
1083 1086
(...skipping 11 matching lines...) Expand all
1095 /* Split with too few output strings available */ 1098 /* Split with too few output strings available */
1096 status = U_ZERO_ERROR; 1099 status = U_ZERO_ERROR;
1097 re = uregex_openC(":", 0, NULL, &status); 1100 re = uregex_openC(":", 0, NULL, &status);
1098 uregex_setText(re, textToSplit, -1, &status); 1101 uregex_setText(re, textToSplit, -1, &status);
1099 TEST_ASSERT_SUCCESS(status); 1102 TEST_ASSERT_SUCCESS(status);
1100 1103
1101 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1104 /* The TEST_ASSERT_SUCCESS call above should change too... */
1102 if(U_SUCCESS(status)) { 1105 if(U_SUCCESS(status)) {
1103 memset(fields, -1, sizeof(fields)); 1106 memset(fields, -1, sizeof(fields));
1104 numFields = 1107 numFields =
1105 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status); 1108 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fie lds, 2, &status);
1106 TEST_ASSERT_SUCCESS(status); 1109 TEST_ASSERT_SUCCESS(status);
1107 1110
1108 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1111 /* The TEST_ASSERT_SUCCESS call above should change too... */
1109 if(U_SUCCESS(status)) { 1112 if(U_SUCCESS(status)) {
1110 TEST_ASSERT(numFields == 2); 1113 TEST_ASSERT(numFields == 2);
1111 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1114 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1112 TEST_ASSERT_STRING(" second: third", fields[1], TRUE); 1115 TEST_ASSERT_STRING(" second: third", fields[1], TRUE);
1113 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*))); 1116 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
1114 1117
1115 spaceNeeded = u_strlen(textToSplit) - 1118 spaceNeeded = u_strlen(textToSplit) -
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1153 * comes out as additional fields. */ 1156 * comes out as additional fields. */
1154 { 1157 {
1155 UChar textToSplit[80]; 1158 UChar textToSplit[80];
1156 UChar buf[200]; 1159 UChar buf[200];
1157 UChar *fields[10]; 1160 UChar *fields[10];
1158 int32_t numFields; 1161 int32_t numFields;
1159 int32_t requiredCapacity; 1162 int32_t requiredCapacity;
1160 int32_t spaceNeeded; 1163 int32_t spaceNeeded;
1161 int32_t sz; 1164 int32_t sz;
1162 1165
1163 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", sizeof(t extToSplit)/2); 1166 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", UPRV_LEN GTHOF(textToSplit));
1164 1167
1165 status = U_ZERO_ERROR; 1168 status = U_ZERO_ERROR;
1166 re = uregex_openC("<(.*?)>", 0, NULL, &status); 1169 re = uregex_openC("<(.*?)>", 0, NULL, &status);
1167 1170
1168 uregex_setText(re, textToSplit, -1, &status); 1171 uregex_setText(re, textToSplit, -1, &status);
1169 TEST_ASSERT_SUCCESS(status); 1172 TEST_ASSERT_SUCCESS(status);
1170 1173
1171 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1174 /* The TEST_ASSERT_SUCCESS call above should change too... */
1172 if(U_SUCCESS(status)) { 1175 if(U_SUCCESS(status)) {
1173 memset(fields, -1, sizeof(fields)); 1176 memset(fields, -1, sizeof(fields));
1174 numFields = 1177 numFields =
1175 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status); 1178 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fie lds, 10, &status);
1176 TEST_ASSERT_SUCCESS(status); 1179 TEST_ASSERT_SUCCESS(status);
1177 1180
1178 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1181 /* The TEST_ASSERT_SUCCESS call above should change too... */
1179 if(U_SUCCESS(status)) { 1182 if(U_SUCCESS(status)) {
1180 TEST_ASSERT(numFields == 5); 1183 TEST_ASSERT(numFields == 5);
1181 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1184 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1182 TEST_ASSERT_STRING("tag-a", fields[1], TRUE); 1185 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1183 TEST_ASSERT_STRING(" second", fields[2], TRUE); 1186 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1184 TEST_ASSERT_STRING("tag-b", fields[3], TRUE); 1187 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1185 TEST_ASSERT_STRING(" third", fields[4], TRUE); 1188 TEST_ASSERT_STRING(" third", fields[4], TRUE);
1186 TEST_ASSERT(fields[5] == NULL); 1189 TEST_ASSERT(fields[5] == NULL);
1187 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */ 1190 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
1188 TEST_ASSERT(spaceNeeded == requiredCapacity); 1191 TEST_ASSERT(spaceNeeded == requiredCapacity);
1189 } 1192 }
1190 } 1193 }
1191 1194
1192 /* Split with too few output strings available (2) */ 1195 /* Split with too few output strings available (2) */
1193 status = U_ZERO_ERROR; 1196 status = U_ZERO_ERROR;
1194 memset(fields, -1, sizeof(fields)); 1197 memset(fields, -1, sizeof(fields));
1195 numFields = 1198 numFields =
1196 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, & status); 1199 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 2, &status);
1197 TEST_ASSERT_SUCCESS(status); 1200 TEST_ASSERT_SUCCESS(status);
1198 1201
1199 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1202 /* The TEST_ASSERT_SUCCESS call above should change too... */
1200 if(U_SUCCESS(status)) { 1203 if(U_SUCCESS(status)) {
1201 TEST_ASSERT(numFields == 2); 1204 TEST_ASSERT(numFields == 2);
1202 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1205 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1203 TEST_ASSERT_STRING(" second<tag-b> third", fields[1], TRUE); 1206 TEST_ASSERT_STRING(" second<tag-b> third", fields[1], TRUE);
1204 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*))); 1207 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
1205 1208
1206 spaceNeeded = strlen("first . second<tag-b> third."); /* "." at NU L positions */ 1209 spaceNeeded = strlen("first . second<tag-b> third."); /* "." at NU L positions */
1207 TEST_ASSERT(spaceNeeded == requiredCapacity); 1210 TEST_ASSERT(spaceNeeded == requiredCapacity);
1208 } 1211 }
1209 1212
1210 /* Split with too few output strings available (3) */ 1213 /* Split with too few output strings available (3) */
1211 status = U_ZERO_ERROR; 1214 status = U_ZERO_ERROR;
1212 memset(fields, -1, sizeof(fields)); 1215 memset(fields, -1, sizeof(fields));
1213 numFields = 1216 numFields =
1214 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 3, & status); 1217 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 3, &status);
1215 TEST_ASSERT_SUCCESS(status); 1218 TEST_ASSERT_SUCCESS(status);
1216 1219
1217 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1220 /* The TEST_ASSERT_SUCCESS call above should change too... */
1218 if(U_SUCCESS(status)) { 1221 if(U_SUCCESS(status)) {
1219 TEST_ASSERT(numFields == 3); 1222 TEST_ASSERT(numFields == 3);
1220 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1223 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1221 TEST_ASSERT_STRING("tag-a", fields[1], TRUE); 1224 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1222 TEST_ASSERT_STRING(" second<tag-b> third", fields[2], TRUE); 1225 TEST_ASSERT_STRING(" second<tag-b> third", fields[2], TRUE);
1223 TEST_ASSERT(!memcmp(&fields[3],&minus1,sizeof(UChar*))); 1226 TEST_ASSERT(!memcmp(&fields[3],&minus1,sizeof(UChar*)));
1224 1227
1225 spaceNeeded = strlen("first .tag-a. second<tag-b> third."); /* "." at NUL positions */ 1228 spaceNeeded = strlen("first .tag-a. second<tag-b> third."); /* "." at NUL positions */
1226 TEST_ASSERT(spaceNeeded == requiredCapacity); 1229 TEST_ASSERT(spaceNeeded == requiredCapacity);
1227 } 1230 }
1228 1231
1229 /* Split with just enough output strings available (5) */ 1232 /* Split with just enough output strings available (5) */
1230 status = U_ZERO_ERROR; 1233 status = U_ZERO_ERROR;
1231 memset(fields, -1, sizeof(fields)); 1234 memset(fields, -1, sizeof(fields));
1232 numFields = 1235 numFields =
1233 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 5, & status); 1236 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 5, &status);
1234 TEST_ASSERT_SUCCESS(status); 1237 TEST_ASSERT_SUCCESS(status);
1235 1238
1236 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1239 /* The TEST_ASSERT_SUCCESS call above should change too... */
1237 if(U_SUCCESS(status)) { 1240 if(U_SUCCESS(status)) {
1238 TEST_ASSERT(numFields == 5); 1241 TEST_ASSERT(numFields == 5);
1239 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1242 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1240 TEST_ASSERT_STRING("tag-a", fields[1], TRUE); 1243 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1241 TEST_ASSERT_STRING(" second", fields[2], TRUE); 1244 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1242 TEST_ASSERT_STRING("tag-b", fields[3], TRUE); 1245 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1243 TEST_ASSERT_STRING(" third", fields[4], TRUE); 1246 TEST_ASSERT_STRING(" third", fields[4], TRUE);
1244 TEST_ASSERT(!memcmp(&fields[5],&minus1,sizeof(UChar*))); 1247 TEST_ASSERT(!memcmp(&fields[5],&minus1,sizeof(UChar*)));
1245 1248
1246 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */ 1249 spaceNeeded = strlen("first .tag-a. second.tag-b. third."); /* "." at NUL positions */
1247 TEST_ASSERT(spaceNeeded == requiredCapacity); 1250 TEST_ASSERT(spaceNeeded == requiredCapacity);
1248 } 1251 }
1249 1252
1250 /* Split, end of text is a field delimiter. */ 1253 /* Split, end of text is a field delimiter. */
1251 status = U_ZERO_ERROR; 1254 status = U_ZERO_ERROR;
1252 sz = strlen("first <tag-a> second<tag-b>"); 1255 sz = strlen("first <tag-a> second<tag-b>");
1253 uregex_setText(re, textToSplit, sz, &status); 1256 uregex_setText(re, textToSplit, sz, &status);
1254 TEST_ASSERT_SUCCESS(status); 1257 TEST_ASSERT_SUCCESS(status);
1255 1258
1256 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1259 /* The TEST_ASSERT_SUCCESS call above should change too... */
1257 if(U_SUCCESS(status)) { 1260 if(U_SUCCESS(status)) {
1258 memset(fields, -1, sizeof(fields)); 1261 memset(fields, -1, sizeof(fields));
1259 numFields = 1262 numFields =
1260 uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 9, &status); 1263 uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fie lds, 9, &status);
1261 TEST_ASSERT_SUCCESS(status); 1264 TEST_ASSERT_SUCCESS(status);
1262 1265
1263 /* The TEST_ASSERT_SUCCESS call above should change too... */ 1266 /* The TEST_ASSERT_SUCCESS call above should change too... */
1264 if(U_SUCCESS(status)) { 1267 if(U_SUCCESS(status)) {
1265 TEST_ASSERT(numFields == 5); 1268 TEST_ASSERT(numFields == 5);
1266 TEST_ASSERT_STRING("first ", fields[0], TRUE); 1269 TEST_ASSERT_STRING("first ", fields[0], TRUE);
1267 TEST_ASSERT_STRING("tag-a", fields[1], TRUE); 1270 TEST_ASSERT_STRING("tag-a", fields[1], TRUE);
1268 TEST_ASSERT_STRING(" second", fields[2], TRUE); 1271 TEST_ASSERT_STRING(" second", fields[2], TRUE);
1269 TEST_ASSERT_STRING("tag-b", fields[3], TRUE); 1272 TEST_ASSERT_STRING("tag-b", fields[3], TRUE);
1270 TEST_ASSERT_STRING("", fields[4], TRUE); 1273 TEST_ASSERT_STRING("", fields[4], TRUE);
(...skipping 186 matching lines...) Expand 10 before | Expand all | Expand 10 after
1457 clone2 = uregex_clone(re, &status); 1460 clone2 = uregex_clone(re, &status);
1458 TEST_ASSERT_SUCCESS(status); 1461 TEST_ASSERT_SUCCESS(status);
1459 TEST_ASSERT(clone2 != NULL); 1462 TEST_ASSERT(clone2 != NULL);
1460 uregex_close(re); 1463 uregex_close(re);
1461 1464
1462 status = U_ZERO_ERROR; 1465 status = U_ZERO_ERROR;
1463 clone3 = uregex_clone(clone2, &status); 1466 clone3 = uregex_clone(clone2, &status);
1464 TEST_ASSERT_SUCCESS(status); 1467 TEST_ASSERT_SUCCESS(status);
1465 TEST_ASSERT(clone3 != NULL); 1468 TEST_ASSERT(clone3 != NULL);
1466 1469
1467 u_uastrncpy(testString1, "abcccd", sizeof(pat)/2); 1470 u_uastrncpy(testString1, "abcccd", UPRV_LENGTHOF(pat));
1468 u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2); 1471 u_uastrncpy(testString2, "xxxabcccd", UPRV_LENGTHOF(pat));
1469 1472
1470 status = U_ZERO_ERROR; 1473 status = U_ZERO_ERROR;
1471 uregex_setText(clone1, testString1, -1, &status); 1474 uregex_setText(clone1, testString1, -1, &status);
1472 TEST_ASSERT_SUCCESS(status); 1475 TEST_ASSERT_SUCCESS(status);
1473 result = uregex_lookingAt(clone1, 0, &status); 1476 result = uregex_lookingAt(clone1, 0, &status);
1474 TEST_ASSERT_SUCCESS(status); 1477 TEST_ASSERT_SUCCESS(status);
1475 TEST_ASSERT(result==TRUE); 1478 TEST_ASSERT(result==TRUE);
1476 1479
1477 status = U_ZERO_ERROR; 1480 status = U_ZERO_ERROR;
1478 uregex_setText(clone2, testString2, -1, &status); 1481 uregex_setText(clone2, testString2, -1, &status);
(...skipping 13 matching lines...) Expand all
1492 1495
1493 /* 1496 /*
1494 * pattern() and patternText() 1497 * pattern() and patternText()
1495 */ 1498 */
1496 { 1499 {
1497 const UChar *resultPat; 1500 const UChar *resultPat;
1498 int32_t resultLen; 1501 int32_t resultLen;
1499 UText *resultText; 1502 UText *resultText;
1500 const char str_hello[] = { 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00 }; /* hell o */ 1503 const char str_hello[] = { 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00 }; /* hell o */
1501 const char str_hel[] = { 0x68, 0x65, 0x6c, 0x00 }; /* hel */ 1504 const char str_hel[] = { 0x68, 0x65, 0x6c, 0x00 }; /* hel */
1502 u_uastrncpy(pat, "hello", sizeof(pat)/2); /* for comparison */ 1505 u_uastrncpy(pat, "hello", UPRV_LENGTHOF(pat)); /* for comparison */
1503 status = U_ZERO_ERROR; 1506 status = U_ZERO_ERROR;
1504 1507
1505 utext_openUTF8(&patternText, str_hello, -1, &status); 1508 utext_openUTF8(&patternText, str_hello, -1, &status);
1506 re = uregex_open(pat, -1, 0, NULL, &status); 1509 re = uregex_open(pat, -1, 0, NULL, &status);
1507 resultPat = uregex_pattern(re, &resultLen, &status); 1510 resultPat = uregex_pattern(re, &resultLen, &status);
1508 TEST_ASSERT_SUCCESS(status); 1511 TEST_ASSERT_SUCCESS(status);
1509 1512
1510 /* The TEST_ASSERT_SUCCESS above should change too... */ 1513 /* The TEST_ASSERT_SUCCESS above should change too... */
1511 if (U_SUCCESS(status)) { 1514 if (U_SUCCESS(status)) {
1512 TEST_ASSERT(resultLen == -1); 1515 TEST_ASSERT(resultLen == -1);
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
1595 UText *resultText; 1598 UText *resultText;
1596 const UChar *result; 1599 const UChar *result;
1597 int32_t textLength; 1600 int32_t textLength;
1598 const char str_abcccd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x65, 0x00 }; /* abcccd */ 1601 const char str_abcccd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x65, 0x00 }; /* abcccd */
1599 const char str_abcccxd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x79, 0x65, 0 x00 }; /* abcccxd */ 1602 const char str_abcccxd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x79, 0x65, 0 x00 }; /* abcccxd */
1600 const char str_abcd[] = { 0x62, 0x63, 0x64, 0x2b, 0x65, 0x00 }; /* abc*d */ 1603 const char str_abcd[] = { 0x62, 0x63, 0x64, 0x2b, 0x65, 0x00 }; /* abc*d */
1601 1604
1602 1605
1603 status = U_ZERO_ERROR; 1606 status = U_ZERO_ERROR;
1604 utext_openUTF8(&text1, str_abcccd, -1, &status); 1607 utext_openUTF8(&text1, str_abcccd, -1, &status);
1605 u_uastrncpy(text2Chars, str_abcccxd, sizeof(text2)/2); 1608 u_uastrncpy(text2Chars, str_abcccxd, UPRV_LENGTHOF(text2Chars));
1606 utext_openUChars(&text2, text2Chars, -1, &status); 1609 utext_openUChars(&text2, text2Chars, -1, &status);
1607 1610
1608 utext_openUTF8(&patternText, str_abcd, -1, &status); 1611 utext_openUTF8(&patternText, str_abcd, -1, &status);
1609 re = uregex_openUText(&patternText, 0, NULL, &status); 1612 re = uregex_openUText(&patternText, 0, NULL, &status);
1610 1613
1611 /* First set a UText */ 1614 /* First set a UText */
1612 uregex_setUText(re, &text1, &status); 1615 uregex_setUText(re, &text1, &status);
1613 resultText = uregex_getUText(re, NULL, &status); 1616 resultText = uregex_getUText(re, NULL, &status);
1614 TEST_ASSERT_SUCCESS(status); 1617 TEST_ASSERT_SUCCESS(status);
1615 TEST_ASSERT(resultText != &text1); 1618 TEST_ASSERT(resultText != &text1);
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
1691 * lookingAt() Used in setText test. 1694 * lookingAt() Used in setText test.
1692 */ 1695 */
1693 1696
1694 1697
1695 /* 1698 /*
1696 * find(), findNext, start, end, reset 1699 * find(), findNext, start, end, reset
1697 */ 1700 */
1698 { 1701 {
1699 UChar text1[50]; 1702 UChar text1[50];
1700 UBool result; 1703 UBool result;
1701 u_uastrncpy(text1, "012rx5rx890rxrx...", sizeof(text1)/2); 1704 u_uastrncpy(text1, "012rx5rx890rxrx...", UPRV_LENGTHOF(text1));
1702 status = U_ZERO_ERROR; 1705 status = U_ZERO_ERROR;
1703 re = uregex_openC("rx", 0, NULL, &status); 1706 re = uregex_openC("rx", 0, NULL, &status);
1704 1707
1705 uregex_setText(re, text1, -1, &status); 1708 uregex_setText(re, text1, -1, &status);
1706 result = uregex_find(re, 0, &status); 1709 result = uregex_find(re, 0, &status);
1707 TEST_ASSERT(result == TRUE); 1710 TEST_ASSERT(result == TRUE);
1708 TEST_ASSERT(uregex_start(re, 0, &status) == 3); 1711 TEST_ASSERT(uregex_start(re, 0, &status) == 3);
1709 TEST_ASSERT(uregex_end(re, 0, &status) == 5); 1712 TEST_ASSERT(uregex_end(re, 0, &status) == 5);
1710 TEST_ASSERT_SUCCESS(status); 1713 TEST_ASSERT_SUCCESS(status);
1711 1714
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
1755 */ 1758 */
1756 { 1759 {
1757 UChar text1[80]; 1760 UChar text1[80];
1758 UText *actual; 1761 UText *actual;
1759 UBool result; 1762 UBool result;
1760 1763
1761 const char str_abcinteriordef[] = { 0x61, 0x62, 0x63, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x00 }; /* abc inter ior def */ 1764 const char str_abcinteriordef[] = { 0x61, 0x62, 0x63, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x00 }; /* abc inter ior def */
1762 const char str_interior[] = { 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x00 }; /* ' interior ' */ 1765 const char str_interior[] = { 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x00 }; /* ' interior ' */
1763 1766
1764 1767
1765 u_uastrncpy(text1, "noise abc interior def, and this is off the end", s izeof(text1)/2); 1768 u_uastrncpy(text1, "noise abc interior def, and this is off the end", U PRV_LENGTHOF(text1));
1766 1769
1767 status = U_ZERO_ERROR; 1770 status = U_ZERO_ERROR;
1768 re = uregex_openC("abc(.*?)def", 0, NULL, &status); 1771 re = uregex_openC("abc(.*?)def", 0, NULL, &status);
1769 TEST_ASSERT_SUCCESS(status); 1772 TEST_ASSERT_SUCCESS(status);
1770 1773
1771 uregex_setText(re, text1, -1, &status); 1774 uregex_setText(re, text1, -1, &status);
1772 result = uregex_find(re, 0, &status); 1775 result = uregex_find(re, 0, &status);
1773 TEST_ASSERT(result==TRUE); 1776 TEST_ASSERT(result==TRUE);
1774 1777
1775 /* Capture Group 0, the full match. Should succeed. */ 1778 /* Capture Group 0, the full match. Should succeed. */
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1833 UChar text1[80]; 1836 UChar text1[80];
1834 UChar text2[80]; 1837 UChar text2[80];
1835 UText replText = UTEXT_INITIALIZER; 1838 UText replText = UTEXT_INITIALIZER;
1836 UText *result; 1839 UText *result;
1837 const char str_Replxxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0 x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2 e, 0x78, 0x2e, 0x00 }; /* Replace <aa> x1x x...x. */ 1840 const char str_Replxxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0 x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2 e, 0x78, 0x2e, 0x00 }; /* Replace <aa> x1x x...x. */
1838 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x6 3, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */ 1841 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x6 3, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
1839 const char str_u00411U00000042a[] = { 0x5c, 0x5c, 0x5c, 0x75, 0x30, 0x3 0, 0x34, 0x31, 0x24, 0x31, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x24, 0x5c, 0x61, 0x00 }; /* \\\u0041$1\U00000042$\a */ 1842 const char str_u00411U00000042a[] = { 0x5c, 0x5c, 0x5c, 0x75, 0x30, 0x3 0, 0x34, 0x31, 0x24, 0x31, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x24, 0x5c, 0x61, 0x00 }; /* \\\u0041$1\U00000042$\a */
1840 const char str_1x[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */ 1843 const char str_1x[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
1841 const char str_ReplaceAaaBax1xxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x6 3, 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. */ 1844 const char str_ReplaceAaaBax1xxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x6 3, 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. */
1842 status = U_ZERO_ERROR; 1845 status = U_ZERO_ERROR;
1843 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 1846 u_uastrncpy(text1, "Replace xaax x1x x...x.", UPRV_LENGTHOF(text1));
1844 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 1847 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
1845 utext_openUTF8(&replText, str_1x, -1, &status); 1848 utext_openUTF8(&replText, str_1x, -1, &status);
1846 1849
1847 re = uregex_openC("x(.*?)x", 0, NULL, &status); 1850 re = uregex_openC("x(.*?)x", 0, NULL, &status);
1848 TEST_ASSERT_SUCCESS(status); 1851 TEST_ASSERT_SUCCESS(status);
1849 1852
1850 /* Normal case, with match */ 1853 /* Normal case, with match */
1851 uregex_setText(re, text1, -1, &status); 1854 uregex_setText(re, text1, -1, &status);
1852 result = uregex_replaceFirstUText(re, &replText, NULL, &status); 1855 result = uregex_replaceFirstUText(re, &replText, NULL, &status);
1853 TEST_ASSERT_SUCCESS(status); 1856 TEST_ASSERT_SUCCESS(status);
1854 TEST_ASSERT_UTEXT(str_Replxxx, result); 1857 TEST_ASSERT_UTEXT(str_Replxxx, result);
(...skipping 24 matching lines...) Expand all
1879 */ 1882 */
1880 { 1883 {
1881 UChar text1[80]; 1884 UChar text1[80];
1882 UChar text2[80]; 1885 UChar text2[80];
1883 UText replText = UTEXT_INITIALIZER; 1886 UText replText = UTEXT_INITIALIZER;
1884 UText *result; 1887 UText *result;
1885 const char str_1[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */ 1888 const char str_1[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
1886 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> <...>. */ 1889 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> <...>. */
1887 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x6 3, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */ 1890 const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x6 3, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
1888 status = U_ZERO_ERROR; 1891 status = U_ZERO_ERROR;
1889 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 1892 u_uastrncpy(text1, "Replace xaax x1x x...x.", UPRV_LENGTHOF(text1));
1890 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 1893 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
1891 utext_openUTF8(&replText, str_1, -1, &status); 1894 utext_openUTF8(&replText, str_1, -1, &status);
1892 1895
1893 re = uregex_openC("x(.*?)x", 0, NULL, &status); 1896 re = uregex_openC("x(.*?)x", 0, NULL, &status);
1894 TEST_ASSERT_SUCCESS(status); 1897 TEST_ASSERT_SUCCESS(status);
1895 1898
1896 /* Normal case, with match */ 1899 /* Normal case, with match */
1897 uregex_setText(re, text1, -1, &status); 1900 uregex_setText(re, text1, -1, &status);
1898 result = uregex_replaceAllUText(re, &replText, NULL, &status); 1901 result = uregex_replaceAllUText(re, &replText, NULL, &status);
1899 TEST_ASSERT_SUCCESS(status); 1902 TEST_ASSERT_SUCCESS(status);
1900 TEST_ASSERT_UTEXT(str_Replaceaa1, result); 1903 TEST_ASSERT_UTEXT(str_Replaceaa1, result);
(...skipping 18 matching lines...) Expand all
1919 UChar text[100]; 1922 UChar text[100];
1920 UChar repl[100]; 1923 UChar repl[100];
1921 UChar buf[100]; 1924 UChar buf[100];
1922 UChar *bufPtr; 1925 UChar *bufPtr;
1923 int32_t bufCap; 1926 int32_t bufCap;
1924 1927
1925 status = U_ZERO_ERROR; 1928 status = U_ZERO_ERROR;
1926 re = uregex_openC(".*", 0, 0, &status); 1929 re = uregex_openC(".*", 0, 0, &status);
1927 TEST_ASSERT_SUCCESS(status); 1930 TEST_ASSERT_SUCCESS(status);
1928 1931
1929 u_uastrncpy(text, "whatever", sizeof(text)/2); 1932 u_uastrncpy(text, "whatever", UPRV_LENGTHOF(text));
1930 u_uastrncpy(repl, "some other", sizeof(repl)/2); 1933 u_uastrncpy(repl, "some other", UPRV_LENGTHOF(repl));
1931 uregex_setText(re, text, -1, &status); 1934 uregex_setText(re, text, -1, &status);
1932 1935
1933 /* match covers whole target string */ 1936 /* match covers whole target string */
1934 uregex_find(re, 0, &status); 1937 uregex_find(re, 0, &status);
1935 TEST_ASSERT_SUCCESS(status); 1938 TEST_ASSERT_SUCCESS(status);
1936 bufPtr = buf; 1939 bufPtr = buf;
1937 bufCap = sizeof(buf) / 2; 1940 bufCap = UPRV_LENGTHOF(buf);
1938 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status); 1941 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1939 TEST_ASSERT_SUCCESS(status); 1942 TEST_ASSERT_SUCCESS(status);
1940 TEST_ASSERT_STRING("some other", buf, TRUE); 1943 TEST_ASSERT_STRING("some other", buf, TRUE);
1941 1944
1942 /* Match has \u \U escapes */ 1945 /* Match has \u \U escapes */
1943 uregex_find(re, 0, &status); 1946 uregex_find(re, 0, &status);
1944 TEST_ASSERT_SUCCESS(status); 1947 TEST_ASSERT_SUCCESS(status);
1945 bufPtr = buf; 1948 bufPtr = buf;
1946 bufCap = sizeof(buf) / 2; 1949 bufCap = UPRV_LENGTHOF(buf);
1947 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2); 1950 u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", UPRV_LENGTHOF(re pl));
1948 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status); 1951 uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
1949 TEST_ASSERT_SUCCESS(status); 1952 TEST_ASSERT_SUCCESS(status);
1950 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE); 1953 TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE);
1951 1954
1952 uregex_close(re); 1955 uregex_close(re);
1953 } 1956 }
1954 1957
1955 1958
1956 /* 1959 /*
1957 * appendReplacement(), appendTail() checked in replaceFirst(), replaceAll( ). 1960 * appendReplacement(), appendTail() checked in replaceFirst(), replaceAll( ).
1958 */ 1961 */
1959 1962
1960 /* 1963 /*
1961 * splitUText() 1964 * splitUText()
1962 */ 1965 */
1963 { 1966 {
1964 UChar textToSplit[80]; 1967 UChar textToSplit[80];
1965 UChar text2[80]; 1968 UChar text2[80];
1966 UText *fields[10]; 1969 UText *fields[10];
1967 int32_t numFields; 1970 int32_t numFields;
1968 int32_t i; 1971 int32_t i;
1969 1972
1970 u_uastrncpy(textToSplit, "first : second: third", sizeof(textToSplit)/ 2); 1973 u_uastrncpy(textToSplit, "first : second: third", UPRV_LENGTHOF(textTo Split));
1971 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 1974 u_uastrncpy(text2, "No match here.", UPRV_LENGTHOF(text2));
1972 1975
1973 status = U_ZERO_ERROR; 1976 status = U_ZERO_ERROR;
1974 re = uregex_openC(":", 0, NULL, &status); 1977 re = uregex_openC(":", 0, NULL, &status);
1975 1978
1976 1979
1977 /* Simple split */ 1980 /* Simple split */
1978 1981
1979 uregex_setText(re, textToSplit, -1, &status); 1982 uregex_setText(re, textToSplit, -1, &status);
1980 TEST_ASSERT_SUCCESS(status); 1983 TEST_ASSERT_SUCCESS(status);
1981 1984
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
2036 } 2039 }
2037 2040
2038 /* splitUText(), part 2. Patterns with capture groups. The capture group t ext 2041 /* splitUText(), part 2. Patterns with capture groups. The capture group t ext
2039 * comes out as additional fields. */ 2042 * comes out as additional fields. */
2040 { 2043 {
2041 UChar textToSplit[80]; 2044 UChar textToSplit[80];
2042 UText *fields[10]; 2045 UText *fields[10];
2043 int32_t numFields; 2046 int32_t numFields;
2044 int32_t i; 2047 int32_t i;
2045 2048
2046 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", sizeof(t extToSplit)/2); 2049 u_uastrncpy(textToSplit, "first <tag-a> second<tag-b> third", UPRV_LEN GTHOF(textToSplit));
2047 2050
2048 status = U_ZERO_ERROR; 2051 status = U_ZERO_ERROR;
2049 re = uregex_openC("<(.*?)>", 0, NULL, &status); 2052 re = uregex_openC("<(.*?)>", 0, NULL, &status);
2050 2053
2051 uregex_setText(re, textToSplit, -1, &status); 2054 uregex_setText(re, textToSplit, -1, &status);
2052 TEST_ASSERT_SUCCESS(status); 2055 TEST_ASSERT_SUCCESS(status);
2053 2056
2054 /* The TEST_ASSERT_SUCCESS call above should change too... */ 2057 /* The TEST_ASSERT_SUCCESS call above should change too... */
2055 if(U_SUCCESS(status)) { 2058 if(U_SUCCESS(status)) {
2056 memset(fields, 0, sizeof(fields)); 2059 memset(fields, 0, sizeof(fields));
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after
2259 2262
2260 uregex_setTimeLimit(re, 100, &status); 2263 uregex_setTimeLimit(re, 100, &status);
2261 TEST_ASSERT_SUCCESS(status); 2264 TEST_ASSERT_SUCCESS(status);
2262 limit = uregex_getTimeLimit(re, &status); 2265 limit = uregex_getTimeLimit(re, &status);
2263 TEST_ASSERT_SUCCESS(status); 2266 TEST_ASSERT_SUCCESS(status);
2264 TEST_ASSERT(limit == 100); 2267 TEST_ASSERT(limit == 100);
2265 2268
2266 uregex_close(re); 2269 uregex_close(re);
2267 } 2270 }
2268 2271
2272 static UBool U_CALLCONV FindCallback(const void* context , int64_t matchIndex) {
2273 return FALSE;
2274 }
2275
2276 static UBool U_CALLCONV MatchCallback(const void *context, int32_t steps) {
2277 return FALSE;
2278 }
2279
2280 static void TestBug10815() {
2281 /* Bug 10815: uregex_findNext() does not set U_REGEX_STOPPED_BY_CALLER
2282 * when the callback function specified by uregex_setMatchCallbac k() returns FALSE
2283 */
2284 URegularExpression *re;
2285 UErrorCode status = U_ZERO_ERROR;
2286 UChar text[100];
2287
2288
2289 // findNext() with a find progress callback function.
2290
2291 re = uregex_openC(".z", 0, 0, &status);
2292 TEST_ASSERT_SUCCESS(status);
2293
2294 u_uastrncpy(text, "Hello, World.", UPRV_LENGTHOF(text));
2295 uregex_setText(re, text, -1, &status);
2296 TEST_ASSERT_SUCCESS(status);
2297
2298 uregex_setFindProgressCallback(re, FindCallback, NULL, &status);
2299 TEST_ASSERT_SUCCESS(status);
2300
2301 uregex_findNext(re, &status);
2302 TEST_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
2303
2304 uregex_close(re);
2305
2306 // findNext() with a match progress callback function.
2307
2308 status = U_ZERO_ERROR;
2309 re = uregex_openC("((xxx)*)*y", 0, 0, &status);
2310 TEST_ASSERT_SUCCESS(status);
2311
2312 // Pattern + this text gives an exponential time match. Without the callback to stop the match,
2313 // it will appear to be stuck in a (near) infinite loop.
2314 u_uastrncpy(text, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxx", UPRV_LENGTHOF(text));
2315 uregex_setText(re, text, -1, &status);
2316 TEST_ASSERT_SUCCESS(status);
2317
2318 uregex_setMatchCallback(re, MatchCallback, NULL, &status);
2319 TEST_ASSERT_SUCCESS(status);
2320
2321 uregex_findNext(re, &status);
2322 TEST_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
2323
2324 uregex_close(re);
2325 }
2326
2269 2327
2270 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */ 2328 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
OLDNEW
« no previous file with comments | « source/test/cintltst/nucnvtst.c ('k') | source/test/cintltst/sorttest.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698