1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 2002-2013, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 7 // 8 // regextst.cpp 9 // 10 // ICU Regular Expressions test, part of intltest. 11 // 12 13 /* 14 NOTE!! 15 16 PLEASE be careful about ASCII assumptions in this test. 17 This test is one of the worst repeat offenders. 18 If you have questions, contact someone on the ICU PMC 19 who has access to an EBCDIC system. 20 21 */ 22 23 #include "intltest.h" 24 #if !UCONFIG_NO_REGULAR_EXPRESSIONS 25 26 #include "unicode/regex.h" 27 #include "unicode/uchar.h" 28 #include "unicode/ucnv.h" 29 #include "unicode/uniset.h" 30 #include "unicode/ustring.h" 31 #include "regextst.h" 32 #include "uvector.h" 33 #include "util.h" 34 #include <stdlib.h> 35 #include <string.h> 36 #include <stdio.h> 37 #include "cstring.h" 38 #include "uinvchar.h" 39 40 #define SUPPORT_MUTATING_INPUT_STRING 0 41 42 //--------------------------------------------------------------------------- 43 // 44 // Test class boilerplate 45 // 46 //--------------------------------------------------------------------------- 47 RegexTest::RegexTest() 48 { 49 } 50 51 52 RegexTest::~RegexTest() 53 { 54 } 55 56 57 58 void RegexTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 59 { 60 if (exec) logln("TestSuite RegexTest: "); 61 switch (index) { 62 63 case 0: name = "Basic"; 64 if (exec) Basic(); 65 break; 66 case 1: name = "API_Match"; 67 if (exec) API_Match(); 68 break; 69 case 2: name = "API_Replace"; 70 if (exec) API_Replace(); 71 break; 72 case 3: name = "API_Pattern"; 73 if (exec) API_Pattern(); 74 break; 75 case 4: 76 #if !UCONFIG_NO_FILE_IO 77 name = "Extended"; 78 if (exec) Extended(); 79 #else 80 name = "skip"; 81 #endif 82 break; 83 case 5: name = "Errors"; 84 if (exec) Errors(); 85 break; 86 case 6: name = "PerlTests"; 87 if (exec) PerlTests(); 88 break; 89 case 7: name = "Callbacks"; 90 if (exec) Callbacks(); 91 break; 92 case 8: name = "FindProgressCallbacks"; 93 if (exec) FindProgressCallbacks(); 94 break; 95 case 9: name = "Bug 6149"; 96 if (exec) Bug6149(); 97 break; 98 case 10: name = "UTextBasic"; 99 if (exec) UTextBasic(); 100 break; 101 case 11: name = "API_Match_UTF8"; 102 if (exec) API_Match_UTF8(); 103 break; 104 case 12: name = "API_Replace_UTF8"; 105 if (exec) API_Replace_UTF8(); 106 break; 107 case 13: name = "API_Pattern_UTF8"; 108 if (exec) API_Pattern_UTF8(); 109 break; 110 case 14: name = "PerlTestsUTF8"; 111 if (exec) PerlTestsUTF8(); 112 break; 113 case 15: name = "PreAllocatedUTextCAPI"; 114 if (exec) PreAllocatedUTextCAPI(); 115 break; 116 case 16: name = "Bug 7651"; 117 if (exec) Bug7651(); 118 break; 119 case 17: name = "Bug 7740"; 120 if (exec) Bug7740(); 121 break; 122 case 18: name = "Bug 8479"; 123 if (exec) Bug8479(); 124 break; 125 case 19: name = "Bug 7029"; 126 if (exec) Bug7029(); 127 break; 128 case 20: name = "CheckInvBufSize"; 129 if (exec) CheckInvBufSize(); 130 break; 131 case 21: name = "Bug 9283"; 132 if (exec) Bug9283(); 133 break; 134 135 default: name = ""; 136 break; //needed to end loop 137 } 138 } 139 140 141 142 /** 143 * Calls utext_openUTF8 after, potentially, converting invariant text from the compilation codepage 144 * into ASCII. 145 * @see utext_openUTF8 146 */ 147 static UText* regextst_openUTF8FromInvariant(UText* ut, const char *inv, int64_t length, UErrorCode *status); 148 149 //--------------------------------------------------------------------------- 150 // 151 // Error Checking / Reporting macros used in all of the tests. 152 // 153 //--------------------------------------------------------------------------- 154 155 static void utextToPrintable(char *buf, int32_t bufLen, UText *text) { 156 int64_t oldIndex = utext_getNativeIndex(text); 157 utext_setNativeIndex(text, 0); 158 char *bufPtr = buf; 159 UChar32 c = utext_next32From(text, 0); 160 while ((c != U_SENTINEL) && (bufPtr < buf+bufLen)) { 161 if (0x000020<=c && c<0x00007e) { 162 *bufPtr = c; 163 } else { 164 #if 0 165 sprintf(bufPtr,"U+%04X", c); 166 bufPtr+= strlen(bufPtr)-1; 167 #else 168 *bufPtr = '%'; 169 #endif 170 } 171 bufPtr++; 172 c = UTEXT_NEXT32(text); 173 } 174 *bufPtr = 0; 175 #if (U_CHARSET_FAMILY==U_EBCDIC_FAMILY) 176 char *ebuf = (char*)malloc(bufLen); 177 uprv_eastrncpy((unsigned char*)ebuf, (const unsigned char*)buf, bufLen); 178 uprv_strncpy(buf, ebuf, bufLen); 179 free((void*)ebuf); 180 #endif 181 utext_setNativeIndex(text, oldIndex); 182 } 183 184 185 static char ASSERT_BUF[1024]; 186 187 const char* RegexTest::extractToAssertBuf(const UnicodeString& message) { 188 if(message.length()==0) { 189 strcpy(ASSERT_BUF, "[[empty UnicodeString]]"); 190 } else { 191 UnicodeString buf; 192 IntlTest::prettify(message,buf); 193 if(buf.length()==0) { 194 strcpy(ASSERT_BUF, "[[escape() returned 0 chars]]"); 195 } else { 196 buf.extract(0, 0x7FFFFFFF, ASSERT_BUF, sizeof(ASSERT_BUF)-1); 197 if(ASSERT_BUF[0]==0) { 198 ASSERT_BUF[0]=0; 199 for(int32_t i=0;i<buf.length();i++) { 200 UChar ch = buf[i]; 201 sprintf(ASSERT_BUF+strlen(ASSERT_BUF),"\\u%02x",ch); 202 } 203 } 204 } 205 } 206 ASSERT_BUF[sizeof(ASSERT_BUF)-1] = 0; 207 return ASSERT_BUF; 208 } 209 210 211 #define REGEX_VERBOSE_TEXT(text) {char buf[200];utextToPrintable(buf,sizeof(buf)/sizeof(buf[0]),text);logln("%s:%d: UText %s=\"%s\"", __FILE__, __LINE__, #text, buf);} 212 213 #define REGEX_CHECK_STATUS {if (U_FAILURE(status)) {dataerrln("%s:%d: RegexTest failure. status=%s", \ 214 __FILE__, __LINE__, u_errorName(status)); return;}} 215 216 #define REGEX_ASSERT(expr) {if ((expr)==FALSE) {errln("%s:%d: RegexTest failure: REGEX_ASSERT(%s) failed \n", __FILE__, __LINE__, #expr);};} 217 218 #define REGEX_ASSERT_FAIL(expr, errcode) {UErrorCode status=U_ZERO_ERROR; (expr);\ 219 if (status!=errcode) {dataerrln("RegexTest failure at line %d. Expected status=%s, got %s", \ 220 __LINE__, u_errorName(errcode), u_errorName(status));};} 221 222 #define REGEX_CHECK_STATUS_L(line) {if (U_FAILURE(status)) {errln( \ 223 "RegexTest failure at line %d, from %d. status=%d\n",__LINE__, (line), status); }} 224 225 #define REGEX_ASSERT_L(expr, line) {if ((expr)==FALSE) { \ 226 errln("RegexTest failure at line %d, from %d.", __LINE__, (line)); return;}} 227 228 #define REGEX_ASSERT_UNISTR(ustr,inv) {if (!(ustr==inv)) {errln("%s:%d: RegexTest failure: REGEX_ASSERT_UNISTR(%s,%s) failed \n", __FILE__, __LINE__, extractToAssertBuf(ustr),inv);};} 229 230 231 static UBool testUTextEqual(UText *uta, UText *utb) { 232 UChar32 ca = 0; 233 UChar32 cb = 0; 234 utext_setNativeIndex(uta, 0); 235 utext_setNativeIndex(utb, 0); 236 do { 237 ca = utext_next32(uta); 238 cb = utext_next32(utb); 239 if (ca != cb) { 240 break; 241 } 242 } while (ca != U_SENTINEL); 243 return ca == cb; 244 } 245 246 247 /** 248 * @param expected expected text in UTF-8 (not platform) codepage 249 */ 250 void RegexTest::assertUText(const char *expected, UText *actual, const char *file, int line) { 251 UErrorCode status = U_ZERO_ERROR; 252 UText expectedText = UTEXT_INITIALIZER; 253 utext_openUTF8(&expectedText, expected, -1, &status); 254 if(U_FAILURE(status)) { 255 errln("%s:%d: assertUText: error %s calling utext_openUTF8(expected: %d chars)\n", file, line, u_errorName(status), strlen(expected)); 256 return; 257 } 258 if(utext_nativeLength(&expectedText)==0 && (strlen(expected)!=0)) { 259 errln("%s:%d: assertUText: expected is %d utf-8 bytes, but utext_nativeLength(expectedText) returned 0.", file, line, strlen(expected)); 260 return; 261 } 262 utext_setNativeIndex(actual, 0); 263 if (!testUTextEqual(&expectedText, actual)) { 264 char buf[201 /*21*/]; 265 char expectedBuf[201]; 266 utextToPrintable(buf, sizeof(buf)/sizeof(buf[0]), actual); 267 utextToPrintable(expectedBuf, sizeof(expectedBuf)/sizeof(expectedBuf[0]), &expectedText); 268 errln("%s:%d: assertUText: Failure: expected \"%s\" (%d chars), got \"%s\" (%d chars)", file, line, expectedBuf, (int)utext_nativeLength(&expectedText), buf, (int)utext_nativeLength(actual)); 269 } 270 utext_close(&expectedText); 271 } 272 /** 273 * @param expected invariant (platform local text) input 274 */ 275 276 void RegexTest::assertUTextInvariant(const char *expected, UText *actual, const char *file, int line) { 277 UErrorCode status = U_ZERO_ERROR; 278 UText expectedText = UTEXT_INITIALIZER; 279 regextst_openUTF8FromInvariant(&expectedText, expected, -1, &status); 280 if(U_FAILURE(status)) { 281 errln("%s:%d: assertUTextInvariant: error %s calling regextst_openUTF8FromInvariant(expected: %d chars)\n", file, line, u_errorName(status), strlen(expected)); 282 return; 283 } 284 utext_setNativeIndex(actual, 0); 285 if (!testUTextEqual(&expectedText, actual)) { 286 char buf[201 /*21*/]; 287 char expectedBuf[201]; 288 utextToPrintable(buf, sizeof(buf)/sizeof(buf[0]), actual); 289 utextToPrintable(expectedBuf, sizeof(expectedBuf)/sizeof(expectedBuf[0]), &expectedText); 290 errln("%s:%d: assertUTextInvariant: Failure: expected \"%s\" (%d uchars), got \"%s\" (%d chars)", file, line, expectedBuf, (int)utext_nativeLength(&expectedText), buf, (int)utext_nativeLength(actual)); 291 } 292 utext_close(&expectedText); 293 } 294 295 /** 296 * Assumes utf-8 input 297 */ 298 #define REGEX_ASSERT_UTEXT_UTF8(expected, actual) assertUText((expected), (actual), __FILE__, __LINE__) 299 /** 300 * Assumes Invariant input 301 */ 302 #define REGEX_ASSERT_UTEXT_INVARIANT(expected, actual) assertUTextInvariant((expected), (actual), __FILE__, __LINE__) 303 304 /** 305 * This buffer ( inv_buf ) is used to hold the UTF-8 strings 306 * passed into utext_openUTF8. An error will be given if 307 * INV_BUFSIZ is too small. It's only used on EBCDIC systems. 308 */ 309 310 #define INV_BUFSIZ 2048 /* increase this if too small */ 311 312 static int64_t inv_next=0; 313 314 #if U_CHARSET_FAMILY!=U_ASCII_FAMILY 315 static char inv_buf[INV_BUFSIZ]; 316 #endif 317 318 static UText* regextst_openUTF8FromInvariant(UText *ut, const char *inv, int64_t length, UErrorCode *status) { 319 if(length==-1) length=strlen(inv); 320 #if U_CHARSET_FAMILY==U_ASCII_FAMILY 321 inv_next+=length; 322 return utext_openUTF8(ut, inv, length, status); 323 #else 324 if(inv_next+length+1>INV_BUFSIZ) { 325 fprintf(stderr, "%s:%d Error: INV_BUFSIZ #defined to be %d but needs to be at least %d.\n", 326 __FILE__, __LINE__, INV_BUFSIZ, (inv_next+length+1)); 327 *status = U_MEMORY_ALLOCATION_ERROR; 328 return NULL; 329 } 330 331 unsigned char *buf = (unsigned char*)inv_buf+inv_next; 332 uprv_aestrncpy(buf, (const uint8_t*)inv, length); 333 inv_next+=length; 334 335 #if 0 336 fprintf(stderr, " Note: INV_BUFSIZ at %d, used=%d\n", INV_BUFSIZ, inv_next); 337 #endif 338 339 return utext_openUTF8(ut, (const char*)buf, length, status); 340 #endif 341 } 342 343 344 //--------------------------------------------------------------------------- 345 // 346 // REGEX_TESTLM Macro + invocation function to simplify writing quick tests 347 // for the LookingAt() and Match() functions. 348 // 349 // usage: 350 // REGEX_TESTLM("pattern", "input text", lookingAt expected, matches expected); 351 // 352 // The expected results are UBool - TRUE or FALSE. 353 // The input text is unescaped. The pattern is not. 354 // 355 // 356 //--------------------------------------------------------------------------- 357 358 #define REGEX_TESTLM(pat, text, looking, match) {doRegexLMTest(pat, text, looking, match, __LINE__);doRegexLMTestUTF8(pat, text, looking, match, __LINE__);} 359 360 UBool RegexTest::doRegexLMTest(const char *pat, const char *text, UBool looking, UBool match, int32_t line) { 361 const UnicodeString pattern(pat, -1, US_INV); 362 const UnicodeString inputText(text, -1, US_INV); 363 UErrorCode status = U_ZERO_ERROR; 364 UParseError pe; 365 RegexPattern *REPattern = NULL; 366 RegexMatcher *REMatcher = NULL; 367 UBool retVal = TRUE; 368 369 UnicodeString patString(pat, -1, US_INV); 370 REPattern = RegexPattern::compile(patString, 0, pe, status); 371 if (U_FAILURE(status)) { 372 dataerrln("RegexTest failure in RegexPattern::compile() at line %d. Status = %s", 373 line, u_errorName(status)); 374 return FALSE; 375 } 376 if (line==376) { RegexPatternDump(REPattern);} 377 378 UnicodeString inputString(inputText); 379 UnicodeString unEscapedInput = inputString.unescape(); 380 REMatcher = REPattern->matcher(unEscapedInput, status); 381 if (U_FAILURE(status)) { 382 errln("RegexTest failure in REPattern::matcher() at line %d. Status = %s\n", 383 line, u_errorName(status)); 384 return FALSE; 385 } 386 387 UBool actualmatch; 388 actualmatch = REMatcher->lookingAt(status); 389 if (U_FAILURE(status)) { 390 errln("RegexTest failure in lookingAt() at line %d. Status = %s\n", 391 line, u_errorName(status)); 392 retVal = FALSE; 393 } 394 if (actualmatch != looking) { 395 errln("RegexTest: wrong return from lookingAt() at line %d.\n", line); 396 retVal = FALSE; 397 } 398 399 status = U_ZERO_ERROR; 400 actualmatch = REMatcher->matches(status); 401 if (U_FAILURE(status)) { 402 errln("RegexTest failure in matches() at line %d. Status = %s\n", 403 line, u_errorName(status)); 404 retVal = FALSE; 405 } 406 if (actualmatch != match) { 407 errln("RegexTest: wrong return from matches() at line %d.\n", line); 408 retVal = FALSE; 409 } 410 411 if (retVal == FALSE) { 412 RegexPatternDump(REPattern); 413 } 414 415 delete REPattern; 416 delete REMatcher; 417 return retVal; 418 } 419 420 421 UBool RegexTest::doRegexLMTestUTF8(const char *pat, const char *text, UBool looking, UBool match, int32_t line) { 422 UText pattern = UTEXT_INITIALIZER; 423 int32_t inputUTF8Length; 424 char *textChars = NULL; 425 UText inputText = UTEXT_INITIALIZER; 426 UErrorCode status = U_ZERO_ERROR; 427 UParseError pe; 428 RegexPattern *REPattern = NULL; 429 RegexMatcher *REMatcher = NULL; 430 UBool retVal = TRUE; 431 432 regextst_openUTF8FromInvariant(&pattern, pat, -1, &status); 433 REPattern = RegexPattern::compile(&pattern, 0, pe, status); 434 if (U_FAILURE(status)) { 435 dataerrln("RegexTest failure in RegexPattern::compile() at line %d (UTF8). Status = %s\n", 436 line, u_errorName(status)); 437 return FALSE; 438 } 439 440 UnicodeString inputString(text, -1, US_INV); 441 UnicodeString unEscapedInput = inputString.unescape(); 442 LocalUConverterPointer UTF8Converter(ucnv_open("UTF8", &status)); 443 ucnv_setFromUCallBack(UTF8Converter.getAlias(), UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status); 444 445 inputUTF8Length = unEscapedInput.extract(NULL, 0, UTF8Converter.getAlias(), status); 446 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) { 447 // UTF-8 does not allow unpaired surrogates, so this could actually happen 448 logln("RegexTest unable to convert input to UTF8 at line %d. Status = %s\n", line, u_errorName(status)); 449 return TRUE; // not a failure of the Regex engine 450 } 451 status = U_ZERO_ERROR; // buffer overflow 452 textChars = new char[inputUTF8Length+1]; 453 unEscapedInput.extract(textChars, inputUTF8Length+1, UTF8Converter.getAlias(), status); 454 utext_openUTF8(&inputText, textChars, inputUTF8Length, &status); 455 456 REMatcher = &REPattern->matcher(status)->reset(&inputText); 457 if (U_FAILURE(status)) { 458 errln("RegexTest failure in REPattern::matcher() at line %d (UTF8). Status = %s\n", 459 line, u_errorName(status)); 460 return FALSE; 461 } 462 463 UBool actualmatch; 464 actualmatch = REMatcher->lookingAt(status); 465 if (U_FAILURE(status)) { 466 errln("RegexTest failure in lookingAt() at line %d (UTF8). Status = %s\n", 467 line, u_errorName(status)); 468 retVal = FALSE; 469 } 470 if (actualmatch != looking) { 471 errln("RegexTest: wrong return from lookingAt() at line %d (UTF8).\n", line); 472 retVal = FALSE; 473 } 474 475 status = U_ZERO_ERROR; 476 actualmatch = REMatcher->matches(status); 477 if (U_FAILURE(status)) { 478 errln("RegexTest failure in matches() at line %d (UTF8). Status = %s\n", 479 line, u_errorName(status)); 480 retVal = FALSE; 481 } 482 if (actualmatch != match) { 483 errln("RegexTest: wrong return from matches() at line %d (UTF8).\n", line); 484 retVal = FALSE; 485 } 486 487 if (retVal == FALSE) { 488 RegexPatternDump(REPattern); 489 } 490 491 delete REPattern; 492 delete REMatcher; 493 utext_close(&inputText); 494 utext_close(&pattern); 495 delete[] textChars; 496 return retVal; 497 } 498 499 500 501 //--------------------------------------------------------------------------- 502 // 503 // REGEX_ERR Macro + invocation function to simplify writing tests 504 // regex tests for incorrect patterns 505 // 506 // usage: 507 // REGEX_ERR("pattern", expected error line, column, expected status); 508 // 509 //--------------------------------------------------------------------------- 510 #define REGEX_ERR(pat, line, col, status) regex_err(pat, line, col, status, __LINE__); 511 512 void RegexTest::regex_err(const char *pat, int32_t errLine, int32_t errCol, 513 UErrorCode expectedStatus, int32_t line) { 514 UnicodeString pattern(pat); 515 516 UErrorCode status = U_ZERO_ERROR; 517 UParseError pe; 518 RegexPattern *callerPattern = NULL; 519 520 // 521 // Compile the caller's pattern 522 // 523 UnicodeString patString(pat); 524 callerPattern = RegexPattern::compile(patString, 0, pe, status); 525 if (status != expectedStatus) { 526 dataerrln("Line %d: unexpected error %s compiling pattern.", line, u_errorName(status)); 527 } else { 528 if (status != U_ZERO_ERROR) { 529 if (pe.line != errLine || pe.offset != errCol) { 530 errln("Line %d: incorrect line/offset from UParseError. Expected %d/%d; got %d/%d.\n", 531 line, errLine, errCol, pe.line, pe.offset); 532 } 533 } 534 } 535 536 delete callerPattern; 537 538 // 539 // Compile again, using a UTF-8-based UText 540 // 541 UText patternText = UTEXT_INITIALIZER; 542 regextst_openUTF8FromInvariant(&patternText, pat, -1, &status); 543 callerPattern = RegexPattern::compile(&patternText, 0, pe, status); 544 if (status != expectedStatus) { 545 dataerrln("Line %d: unexpected error %s compiling pattern.", line, u_errorName(status)); 546 } else { 547 if (status != U_ZERO_ERROR) { 548 if (pe.line != errLine || pe.offset != errCol) { 549 errln("Line %d: incorrect line/offset from UParseError. Expected %d/%d; got %d/%d.\n", 550 line, errLine, errCol, pe.line, pe.offset); 551 } 552 } 553 } 554 555 delete callerPattern; 556 utext_close(&patternText); 557 } 558 559 560 561 //--------------------------------------------------------------------------- 562 // 563 // Basic Check for basic functionality of regex pattern matching. 564 // Avoid the use of REGEX_FIND test macro, which has 565 // substantial dependencies on basic Regex functionality. 566 // 567 //--------------------------------------------------------------------------- 568 void RegexTest::Basic() { 569 570 571 // 572 // Debug - slide failing test cases early 573 // 574 #if 0 575 { 576 // REGEX_TESTLM("a\N{LATIN SMALL LETTER B}c", "abc", FALSE, FALSE); 577 UParseError pe; 578 UErrorCode status = U_ZERO_ERROR; 579 RegexPattern *pattern; 580 pattern = RegexPattern::compile(UNICODE_STRING_SIMPLE("a\\u00dfx").unescape(), UREGEX_CASE_INSENSITIVE, pe, status); 581 RegexPatternDump(pattern); 582 RegexMatcher *m = pattern->matcher(UNICODE_STRING_SIMPLE("a\\u00dfxzzz").unescape(), status); 583 UBool result = m->find(); 584 printf("result = %d\n", result); 585 // REGEX_FIND("", "<0>ab<1>cc</1><2>ccc</2></0>ddd"); 586 // REGEX_FIND("(X([abc=X]+)+X)|(y[abc=]+)", "=XX===================="); 587 } 588 exit(1); 589 #endif 590 591 592 // 593 // Pattern with parentheses 594 // 595 REGEX_TESTLM("st(abc)ring", "stabcring thing", TRUE, FALSE); 596 REGEX_TESTLM("st(abc)ring", "stabcring", TRUE, TRUE); 597 REGEX_TESTLM("st(abc)ring", "stabcrung", FALSE, FALSE); 598 599 // 600 // Patterns with * 601 // 602 REGEX_TESTLM("st(abc)*ring", "string", TRUE, TRUE); 603 REGEX_TESTLM("st(abc)*ring", "stabcring", TRUE, TRUE); 604 REGEX_TESTLM("st(abc)*ring", "stabcabcring", TRUE, TRUE); 605 REGEX_TESTLM("st(abc)*ring", "stabcabcdring", FALSE, FALSE); 606 REGEX_TESTLM("st(abc)*ring", "stabcabcabcring etc.", TRUE, FALSE); 607 608 REGEX_TESTLM("a*", "", TRUE, TRUE); 609 REGEX_TESTLM("a*", "b", TRUE, FALSE); 610 611 612 // 613 // Patterns with "." 614 // 615 REGEX_TESTLM(".", "abc", TRUE, FALSE); 616 REGEX_TESTLM("...", "abc", TRUE, TRUE); 617 REGEX_TESTLM("....", "abc", FALSE, FALSE); 618 REGEX_TESTLM(".*", "abcxyz123", TRUE, TRUE); 619 REGEX_TESTLM("ab.*xyz", "abcdefghij", FALSE, FALSE); 620 REGEX_TESTLM("ab.*xyz", "abcdefg...wxyz", TRUE, TRUE); 621 REGEX_TESTLM("ab.*xyz", "abcde...wxyz...abc..xyz", TRUE, TRUE); 622 REGEX_TESTLM("ab.*xyz", "abcde...wxyz...abc..xyz...", TRUE, FALSE); 623 624 // 625 // Patterns with * applied to chars at end of literal string 626 // 627 REGEX_TESTLM("abc*", "ab", TRUE, TRUE); 628 REGEX_TESTLM("abc*", "abccccc", TRUE, TRUE); 629 630 // 631 // Supplemental chars match as single chars, not a pair of surrogates. 632 // 633 REGEX_TESTLM(".", "\\U00011000", TRUE, TRUE); 634 REGEX_TESTLM("...", "\\U00011000x\\U00012002", TRUE, TRUE); 635 REGEX_TESTLM("...", "\\U00011000x\\U00012002y", TRUE, FALSE); 636 637 638 // 639 // UnicodeSets in the pattern 640 // 641 REGEX_TESTLM("[1-6]", "1", TRUE, TRUE); 642 REGEX_TESTLM("[1-6]", "3", TRUE, TRUE); 643 REGEX_TESTLM("[1-6]", "7", FALSE, FALSE); 644 REGEX_TESTLM("a[1-6]", "a3", TRUE, TRUE); 645 REGEX_TESTLM("a[1-6]", "a3", TRUE, TRUE); 646 REGEX_TESTLM("a[1-6]b", "a3b", TRUE, TRUE); 647 648 REGEX_TESTLM("a[0-9]*b", "a123b", TRUE, TRUE); 649 REGEX_TESTLM("a[0-9]*b", "abc", TRUE, FALSE); 650 REGEX_TESTLM("[\\p{Nd}]*", "123456", TRUE, TRUE); 651 REGEX_TESTLM("[\\p{Nd}]*", "a123456", TRUE, FALSE); // note that * matches 0 occurences. 652 REGEX_TESTLM("[a][b][[:Zs:]]*", "ab ", TRUE, TRUE); 653 654 // 655 // OR operator in patterns 656 // 657 REGEX_TESTLM("(a|b)", "a", TRUE, TRUE); 658 REGEX_TESTLM("(a|b)", "b", TRUE, TRUE); 659 REGEX_TESTLM("(a|b)", "c", FALSE, FALSE); 660 REGEX_TESTLM("a|b", "b", TRUE, TRUE); 661 662 REGEX_TESTLM("(a|b|c)*", "aabcaaccbcabc", TRUE, TRUE); 663 REGEX_TESTLM("(a|b|c)*", "aabcaaccbcabdc", TRUE, FALSE); 664 REGEX_TESTLM("(a(b|c|d)(x|y|z)*|123)", "ac", TRUE, TRUE); 665 REGEX_TESTLM("(a(b|c|d)(x|y|z)*|123)", "123", TRUE, TRUE); 666 REGEX_TESTLM("(a|(1|2)*)(b|c|d)(x|y|z)*|123", "123", TRUE, TRUE); 667 REGEX_TESTLM("(a|(1|2)*)(b|c|d)(x|y|z)*|123", "222211111czzzzw", TRUE, FALSE); 668 669 // 670 // + 671 // 672 REGEX_TESTLM("ab+", "abbc", TRUE, FALSE); 673 REGEX_TESTLM("ab+c", "ac", FALSE, FALSE); 674 REGEX_TESTLM("b+", "", FALSE, FALSE); 675 REGEX_TESTLM("(abc|def)+", "defabc", TRUE, TRUE); 676 REGEX_TESTLM(".+y", "zippity dooy dah ", TRUE, FALSE); 677 REGEX_TESTLM(".+y", "zippity dooy", TRUE, TRUE); 678 679 // 680 // ? 681 // 682 REGEX_TESTLM("ab?", "ab", TRUE, TRUE); 683 REGEX_TESTLM("ab?", "a", TRUE, TRUE); 684 REGEX_TESTLM("ab?", "ac", TRUE, FALSE); 685 REGEX_TESTLM("ab?", "abb", TRUE, FALSE); 686 REGEX_TESTLM("a(b|c)?d", "abd", TRUE, TRUE); 687 REGEX_TESTLM("a(b|c)?d", "acd", TRUE, TRUE); 688 REGEX_TESTLM("a(b|c)?d", "ad", TRUE, TRUE); 689 REGEX_TESTLM("a(b|c)?d", "abcd", FALSE, FALSE); 690 REGEX_TESTLM("a(b|c)?d", "ab", FALSE, FALSE); 691 692 // 693 // Escape sequences that become single literal chars, handled internally 694 // by ICU's Unescape. 695 // 696 697 // REGEX_TESTLM("\101\142", "Ab", TRUE, TRUE); // Octal TODO: not implemented yet. 698 REGEX_TESTLM("\\a", "\\u0007", TRUE, TRUE); // BEL 699 REGEX_TESTLM("\\cL", "\\u000c", TRUE, TRUE); // Control-L 700 REGEX_TESTLM("\\e", "\\u001b", TRUE, TRUE); // Escape 701 REGEX_TESTLM("\\f", "\\u000c", TRUE, TRUE); // Form Feed 702 REGEX_TESTLM("\\n", "\\u000a", TRUE, TRUE); // new line 703 REGEX_TESTLM("\\r", "\\u000d", TRUE, TRUE); // CR 704 REGEX_TESTLM("\\t", "\\u0009", TRUE, TRUE); // Tab 705 REGEX_TESTLM("\\u1234", "\\u1234", TRUE, TRUE); 706 REGEX_TESTLM("\\U00001234", "\\u1234", TRUE, TRUE); 707 708 REGEX_TESTLM(".*\\Ax", "xyz", TRUE, FALSE); // \A matches only at the beginning of input 709 REGEX_TESTLM(".*\\Ax", " xyz", FALSE, FALSE); // \A matches only at the beginning of input 710 711 // Escape of special chars in patterns 712 REGEX_TESTLM("\\\\\\|\\(\\)\\[\\{\\~\\$\\*\\+\\?\\.", "\\\\|()[{~$*+?.", TRUE, TRUE); 713 } 714 715 716 //--------------------------------------------------------------------------- 717 // 718 // UTextBasic Check for quirks that are specific to the UText 719 // implementation. 720 // 721 //--------------------------------------------------------------------------- 722 void RegexTest::UTextBasic() { 723 const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */ 724 UErrorCode status = U_ZERO_ERROR; 725 UText pattern = UTEXT_INITIALIZER; 726 utext_openUTF8(&pattern, str_abc, -1, &status); 727 RegexMatcher matcher(&pattern, 0, status); 728 REGEX_CHECK_STATUS; 729 730 UText input = UTEXT_INITIALIZER; 731 utext_openUTF8(&input, str_abc, -1, &status); 732 REGEX_CHECK_STATUS; 733 matcher.reset(&input); 734 REGEX_CHECK_STATUS; 735 REGEX_ASSERT_UTEXT_UTF8(str_abc, matcher.inputText()); 736 737 matcher.reset(matcher.inputText()); 738 REGEX_CHECK_STATUS; 739 REGEX_ASSERT_UTEXT_UTF8(str_abc, matcher.inputText()); 740 741 utext_close(&pattern); 742 utext_close(&input); 743 } 744 745 746 //--------------------------------------------------------------------------- 747 // 748 // API_Match Test that the API for class RegexMatcher 749 // is present and nominally working, but excluding functions 750 // implementing replace operations. 751 // 752 //--------------------------------------------------------------------------- 753 void RegexTest::API_Match() { 754 UParseError pe; 755 UErrorCode status=U_ZERO_ERROR; 756 int32_t flags = 0; 757 758 // 759 // Debug - slide failing test cases early 760 // 761 #if 0 762 { 763 } 764 return; 765 #endif 766 767 // 768 // Simple pattern compilation 769 // 770 { 771 UnicodeString re("abc"); 772 RegexPattern *pat2; 773 pat2 = RegexPattern::compile(re, flags, pe, status); 774 REGEX_CHECK_STATUS; 775 776 UnicodeString inStr1 = "abcdef this is a test"; 777 UnicodeString instr2 = "not abc"; 778 UnicodeString empty = ""; 779 780 781 // 782 // Matcher creation and reset. 783 // 784 RegexMatcher *m1 = pat2->matcher(inStr1, status); 785 REGEX_CHECK_STATUS; 786 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 787 REGEX_ASSERT(m1->input() == inStr1); 788 m1->reset(instr2); 789 REGEX_ASSERT(m1->lookingAt(status) == FALSE); 790 REGEX_ASSERT(m1->input() == instr2); 791 m1->reset(inStr1); 792 REGEX_ASSERT(m1->input() == inStr1); 793 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 794 m1->reset(empty); 795 REGEX_ASSERT(m1->lookingAt(status) == FALSE); 796 REGEX_ASSERT(m1->input() == empty); 797 REGEX_ASSERT(&m1->pattern() == pat2); 798 799 // 800 // reset(pos, status) 801 // 802 m1->reset(inStr1); 803 m1->reset(4, status); 804 REGEX_CHECK_STATUS; 805 REGEX_ASSERT(m1->input() == inStr1); 806 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 807 808 m1->reset(-1, status); 809 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 810 status = U_ZERO_ERROR; 811 812 m1->reset(0, status); 813 REGEX_CHECK_STATUS; 814 status = U_ZERO_ERROR; 815 816 int32_t len = m1->input().length(); 817 m1->reset(len-1, status); 818 REGEX_CHECK_STATUS; 819 status = U_ZERO_ERROR; 820 821 m1->reset(len, status); 822 REGEX_CHECK_STATUS; 823 status = U_ZERO_ERROR; 824 825 m1->reset(len+1, status); 826 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 827 status = U_ZERO_ERROR; 828 829 // 830 // match(pos, status) 831 // 832 m1->reset(instr2); 833 REGEX_ASSERT(m1->matches(4, status) == TRUE); 834 m1->reset(); 835 REGEX_ASSERT(m1->matches(3, status) == FALSE); 836 m1->reset(); 837 REGEX_ASSERT(m1->matches(5, status) == FALSE); 838 REGEX_ASSERT(m1->matches(4, status) == TRUE); 839 REGEX_ASSERT(m1->matches(-1, status) == FALSE); 840 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 841 842 // Match() at end of string should fail, but should not 843 // be an error. 844 status = U_ZERO_ERROR; 845 len = m1->input().length(); 846 REGEX_ASSERT(m1->matches(len, status) == FALSE); 847 REGEX_CHECK_STATUS; 848 849 // Match beyond end of string should fail with an error. 850 status = U_ZERO_ERROR; 851 REGEX_ASSERT(m1->matches(len+1, status) == FALSE); 852 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 853 854 // Successful match at end of string. 855 { 856 status = U_ZERO_ERROR; 857 RegexMatcher m("A?", 0, status); // will match zero length string. 858 REGEX_CHECK_STATUS; 859 m.reset(inStr1); 860 len = inStr1.length(); 861 REGEX_ASSERT(m.matches(len, status) == TRUE); 862 REGEX_CHECK_STATUS; 863 m.reset(empty); 864 REGEX_ASSERT(m.matches(0, status) == TRUE); 865 REGEX_CHECK_STATUS; 866 } 867 868 869 // 870 // lookingAt(pos, status) 871 // 872 status = U_ZERO_ERROR; 873 m1->reset(instr2); // "not abc" 874 REGEX_ASSERT(m1->lookingAt(4, status) == TRUE); 875 REGEX_ASSERT(m1->lookingAt(5, status) == FALSE); 876 REGEX_ASSERT(m1->lookingAt(3, status) == FALSE); 877 REGEX_ASSERT(m1->lookingAt(4, status) == TRUE); 878 REGEX_ASSERT(m1->lookingAt(-1, status) == FALSE); 879 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 880 status = U_ZERO_ERROR; 881 len = m1->input().length(); 882 REGEX_ASSERT(m1->lookingAt(len, status) == FALSE); 883 REGEX_CHECK_STATUS; 884 REGEX_ASSERT(m1->lookingAt(len+1, status) == FALSE); 885 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 886 887 delete m1; 888 delete pat2; 889 } 890 891 892 // 893 // Capture Group. 894 // RegexMatcher::start(); 895 // RegexMatcher::end(); 896 // RegexMatcher::groupCount(); 897 // 898 { 899 int32_t flags=0; 900 UParseError pe; 901 UErrorCode status=U_ZERO_ERROR; 902 903 UnicodeString re("01(23(45)67)(.*)"); 904 RegexPattern *pat = RegexPattern::compile(re, flags, pe, status); 905 REGEX_CHECK_STATUS; 906 UnicodeString data = "0123456789"; 907 908 RegexMatcher *matcher = pat->matcher(data, status); 909 REGEX_CHECK_STATUS; 910 REGEX_ASSERT(matcher->lookingAt(status) == TRUE); 911 static const int32_t matchStarts[] = {0, 2, 4, 8}; 912 static const int32_t matchEnds[] = {10, 8, 6, 10}; 913 int32_t i; 914 for (i=0; i<4; i++) { 915 int32_t actualStart = matcher->start(i, status); 916 REGEX_CHECK_STATUS; 917 if (actualStart != matchStarts[i]) { 918 errln("RegexTest failure at line %d, index %d. Expected %d, got %d\n", 919 __LINE__, i, matchStarts[i], actualStart); 920 } 921 int32_t actualEnd = matcher->end(i, status); 922 REGEX_CHECK_STATUS; 923 if (actualEnd != matchEnds[i]) { 924 errln("RegexTest failure at line %d index %d. Expected %d, got %d\n", 925 __LINE__, i, matchEnds[i], actualEnd); 926 } 927 } 928 929 REGEX_ASSERT(matcher->start(0, status) == matcher->start(status)); 930 REGEX_ASSERT(matcher->end(0, status) == matcher->end(status)); 931 932 REGEX_ASSERT_FAIL(matcher->start(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 933 REGEX_ASSERT_FAIL(matcher->start( 4, status), U_INDEX_OUTOFBOUNDS_ERROR); 934 matcher->reset(); 935 REGEX_ASSERT_FAIL(matcher->start( 0, status), U_REGEX_INVALID_STATE); 936 937 matcher->lookingAt(status); 938 REGEX_ASSERT(matcher->group(status) == "0123456789"); 939 REGEX_ASSERT(matcher->group(0, status) == "0123456789"); 940 REGEX_ASSERT(matcher->group(1, status) == "234567" ); 941 REGEX_ASSERT(matcher->group(2, status) == "45" ); 942 REGEX_ASSERT(matcher->group(3, status) == "89" ); 943 REGEX_CHECK_STATUS; 944 REGEX_ASSERT_FAIL(matcher->group(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 945 REGEX_ASSERT_FAIL(matcher->group( 4, status), U_INDEX_OUTOFBOUNDS_ERROR); 946 matcher->reset(); 947 REGEX_ASSERT_FAIL(matcher->group( 0, status), U_REGEX_INVALID_STATE); 948 949 delete matcher; 950 delete pat; 951 952 } 953 954 // 955 // find 956 // 957 { 958 int32_t flags=0; 959 UParseError pe; 960 UErrorCode status=U_ZERO_ERROR; 961 962 UnicodeString re("abc"); 963 RegexPattern *pat = RegexPattern::compile(re, flags, pe, status); 964 REGEX_CHECK_STATUS; 965 UnicodeString data = ".abc..abc...abc.."; 966 // 012345678901234567 967 968 RegexMatcher *matcher = pat->matcher(data, status); 969 REGEX_CHECK_STATUS; 970 REGEX_ASSERT(matcher->find()); 971 REGEX_ASSERT(matcher->start(status) == 1); 972 REGEX_ASSERT(matcher->find()); 973 REGEX_ASSERT(matcher->start(status) == 6); 974 REGEX_ASSERT(matcher->find()); 975 REGEX_ASSERT(matcher->start(status) == 12); 976 REGEX_ASSERT(matcher->find() == FALSE); 977 REGEX_ASSERT(matcher->find() == FALSE); 978 979 matcher->reset(); 980 REGEX_ASSERT(matcher->find()); 981 REGEX_ASSERT(matcher->start(status) == 1); 982 983 REGEX_ASSERT(matcher->find(0, status)); 984 REGEX_ASSERT(matcher->start(status) == 1); 985 REGEX_ASSERT(matcher->find(1, status)); 986 REGEX_ASSERT(matcher->start(status) == 1); 987 REGEX_ASSERT(matcher->find(2, status)); 988 REGEX_ASSERT(matcher->start(status) == 6); 989 REGEX_ASSERT(matcher->find(12, status)); 990 REGEX_ASSERT(matcher->start(status) == 12); 991 REGEX_ASSERT(matcher->find(13, status) == FALSE); 992 REGEX_ASSERT(matcher->find(16, status) == FALSE); 993 REGEX_ASSERT(matcher->find(17, status) == FALSE); 994 REGEX_ASSERT_FAIL(matcher->start(status), U_REGEX_INVALID_STATE); 995 996 status = U_ZERO_ERROR; 997 REGEX_ASSERT_FAIL(matcher->find(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 998 status = U_ZERO_ERROR; 999 REGEX_ASSERT_FAIL(matcher->find(18, status), U_INDEX_OUTOFBOUNDS_ERROR); 1000 1001 REGEX_ASSERT(matcher->groupCount() == 0); 1002 1003 delete matcher; 1004 delete pat; 1005 } 1006 1007 1008 // 1009 // find, with \G in pattern (true if at the end of a previous match). 1010 // 1011 { 1012 int32_t flags=0; 1013 UParseError pe; 1014 UErrorCode status=U_ZERO_ERROR; 1015 1016 UnicodeString re(".*?(?:(\\Gabc)|(abc))", -1, US_INV); 1017 RegexPattern *pat = RegexPattern::compile(re, flags, pe, status); 1018 REGEX_CHECK_STATUS; 1019 UnicodeString data = ".abcabc.abc.."; 1020 // 012345678901234567 1021 1022 RegexMatcher *matcher = pat->matcher(data, status); 1023 REGEX_CHECK_STATUS; 1024 REGEX_ASSERT(matcher->find()); 1025 REGEX_ASSERT(matcher->start(status) == 0); 1026 REGEX_ASSERT(matcher->start(1, status) == -1); 1027 REGEX_ASSERT(matcher->start(2, status) == 1); 1028 1029 REGEX_ASSERT(matcher->find()); 1030 REGEX_ASSERT(matcher->start(status) == 4); 1031 REGEX_ASSERT(matcher->start(1, status) == 4); 1032 REGEX_ASSERT(matcher->start(2, status) == -1); 1033 REGEX_CHECK_STATUS; 1034 1035 delete matcher; 1036 delete pat; 1037 } 1038 1039 // 1040 // find with zero length matches, match position should bump ahead 1041 // to prevent loops. 1042 // 1043 { 1044 int32_t i; 1045 UErrorCode status=U_ZERO_ERROR; 1046 RegexMatcher m("(?= ?)", 0, status); // This pattern will zero-length matches anywhere, 1047 // using an always-true look-ahead. 1048 REGEX_CHECK_STATUS; 1049 UnicodeString s(" "); 1050 m.reset(s); 1051 for (i=0; ; i++) { 1052 if (m.find() == FALSE) { 1053 break; 1054 } 1055 REGEX_ASSERT(m.start(status) == i); 1056 REGEX_ASSERT(m.end(status) == i); 1057 } 1058 REGEX_ASSERT(i==5); 1059 1060 // Check that the bump goes over surrogate pairs OK 1061 s = UNICODE_STRING_SIMPLE("\\U00010001\\U00010002\\U00010003\\U00010004"); 1062 s = s.unescape(); 1063 m.reset(s); 1064 for (i=0; ; i+=2) { 1065 if (m.find() == FALSE) { 1066 break; 1067 } 1068 REGEX_ASSERT(m.start(status) == i); 1069 REGEX_ASSERT(m.end(status) == i); 1070 } 1071 REGEX_ASSERT(i==10); 1072 } 1073 { 1074 // find() loop breaking test. 1075 // with pattern of /.?/, should see a series of one char matches, then a single 1076 // match of zero length at the end of the input string. 1077 int32_t i; 1078 UErrorCode status=U_ZERO_ERROR; 1079 RegexMatcher m(".?", 0, status); 1080 REGEX_CHECK_STATUS; 1081 UnicodeString s(" "); 1082 m.reset(s); 1083 for (i=0; ; i++) { 1084 if (m.find() == FALSE) { 1085 break; 1086 } 1087 REGEX_ASSERT(m.start(status) == i); 1088 REGEX_ASSERT(m.end(status) == (i<4 ? i+1 : i)); 1089 } 1090 REGEX_ASSERT(i==5); 1091 } 1092 1093 1094 // 1095 // Matchers with no input string behave as if they had an empty input string. 1096 // 1097 1098 { 1099 UErrorCode status = U_ZERO_ERROR; 1100 RegexMatcher m(".?", 0, status); 1101 REGEX_CHECK_STATUS; 1102 REGEX_ASSERT(m.find()); 1103 REGEX_ASSERT(m.start(status) == 0); 1104 REGEX_ASSERT(m.input() == ""); 1105 } 1106 { 1107 UErrorCode status = U_ZERO_ERROR; 1108 RegexPattern *p = RegexPattern::compile(".", 0, status); 1109 RegexMatcher *m = p->matcher(status); 1110 REGEX_CHECK_STATUS; 1111 1112 REGEX_ASSERT(m->find() == FALSE); 1113 REGEX_ASSERT(m->input() == ""); 1114 delete m; 1115 delete p; 1116 } 1117 1118 // 1119 // Regions 1120 // 1121 { 1122 UErrorCode status = U_ZERO_ERROR; 1123 UnicodeString testString("This is test data"); 1124 RegexMatcher m(".*", testString, 0, status); 1125 REGEX_CHECK_STATUS; 1126 REGEX_ASSERT(m.regionStart() == 0); 1127 REGEX_ASSERT(m.regionEnd() == testString.length()); 1128 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 1129 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 1130 1131 m.region(2,4, status); 1132 REGEX_CHECK_STATUS; 1133 REGEX_ASSERT(m.matches(status)); 1134 REGEX_ASSERT(m.start(status)==2); 1135 REGEX_ASSERT(m.end(status)==4); 1136 REGEX_CHECK_STATUS; 1137 1138 m.reset(); 1139 REGEX_ASSERT(m.regionStart() == 0); 1140 REGEX_ASSERT(m.regionEnd() == testString.length()); 1141 1142 UnicodeString shorterString("short"); 1143 m.reset(shorterString); 1144 REGEX_ASSERT(m.regionStart() == 0); 1145 REGEX_ASSERT(m.regionEnd() == shorterString.length()); 1146 1147 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 1148 REGEX_ASSERT(&m == &m.useAnchoringBounds(FALSE)); 1149 REGEX_ASSERT(m.hasAnchoringBounds() == FALSE); 1150 REGEX_ASSERT(&m == &m.reset()); 1151 REGEX_ASSERT(m.hasAnchoringBounds() == FALSE); 1152 1153 REGEX_ASSERT(&m == &m.useAnchoringBounds(TRUE)); 1154 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 1155 REGEX_ASSERT(&m == &m.reset()); 1156 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 1157 1158 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 1159 REGEX_ASSERT(&m == &m.useTransparentBounds(TRUE)); 1160 REGEX_ASSERT(m.hasTransparentBounds() == TRUE); 1161 REGEX_ASSERT(&m == &m.reset()); 1162 REGEX_ASSERT(m.hasTransparentBounds() == TRUE); 1163 1164 REGEX_ASSERT(&m == &m.useTransparentBounds(FALSE)); 1165 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 1166 REGEX_ASSERT(&m == &m.reset()); 1167 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 1168 1169 } 1170 1171 // 1172 // hitEnd() and requireEnd() 1173 // 1174 { 1175 UErrorCode status = U_ZERO_ERROR; 1176 UnicodeString testString("aabb"); 1177 RegexMatcher m1(".*", testString, 0, status); 1178 REGEX_ASSERT(m1.lookingAt(status) == TRUE); 1179 REGEX_ASSERT(m1.hitEnd() == TRUE); 1180 REGEX_ASSERT(m1.requireEnd() == FALSE); 1181 REGEX_CHECK_STATUS; 1182 1183 status = U_ZERO_ERROR; 1184 RegexMatcher m2("a*", testString, 0, status); 1185 REGEX_ASSERT(m2.lookingAt(status) == TRUE); 1186 REGEX_ASSERT(m2.hitEnd() == FALSE); 1187 REGEX_ASSERT(m2.requireEnd() == FALSE); 1188 REGEX_CHECK_STATUS; 1189 1190 status = U_ZERO_ERROR; 1191 RegexMatcher m3(".*$", testString, 0, status); 1192 REGEX_ASSERT(m3.lookingAt(status) == TRUE); 1193 REGEX_ASSERT(m3.hitEnd() == TRUE); 1194 REGEX_ASSERT(m3.requireEnd() == TRUE); 1195 REGEX_CHECK_STATUS; 1196 } 1197 1198 1199 // 1200 // Compilation error on reset with UChar * 1201 // These were a hazard that people were stumbling over with runtime errors. 1202 // Changed them to compiler errors by adding private methods that more closely 1203 // matched the incorrect use of the functions. 1204 // 1205 #if 0 1206 { 1207 UErrorCode status = U_ZERO_ERROR; 1208 UChar ucharString[20]; 1209 RegexMatcher m(".", 0, status); 1210 m.reset(ucharString); // should not compile. 1211 1212 RegexPattern *p = RegexPattern::compile(".", 0, status); 1213 RegexMatcher *m2 = p->matcher(ucharString, status); // should not compile. 1214 1215 RegexMatcher m3(".", ucharString, 0, status); // Should not compile 1216 } 1217 #endif 1218 1219 // 1220 // Time Outs. 1221 // Note: These tests will need to be changed when the regexp engine is 1222 // able to detect and cut short the exponential time behavior on 1223 // this type of match. 1224 // 1225 { 1226 UErrorCode status = U_ZERO_ERROR; 1227 // Enough 'a's in the string to cause the match to time out. 1228 // (Each on additonal 'a' doubles the time) 1229 UnicodeString testString("aaaaaaaaaaaaaaaaaaaaa"); 1230 RegexMatcher matcher("(a+)+b", testString, 0, status); 1231 REGEX_CHECK_STATUS; 1232 REGEX_ASSERT(matcher.getTimeLimit() == 0); 1233 matcher.setTimeLimit(100, status); 1234 REGEX_ASSERT(matcher.getTimeLimit() == 100); 1235 REGEX_ASSERT(matcher.lookingAt(status) == FALSE); 1236 REGEX_ASSERT(status == U_REGEX_TIME_OUT); 1237 } 1238 { 1239 UErrorCode status = U_ZERO_ERROR; 1240 // Few enough 'a's to slip in under the time limit. 1241 UnicodeString testString("aaaaaaaaaaaaaaaaaa"); 1242 RegexMatcher matcher("(a+)+b", testString, 0, status); 1243 REGEX_CHECK_STATUS; 1244 matcher.setTimeLimit(100, status); 1245 REGEX_ASSERT(matcher.lookingAt(status) == FALSE); 1246 REGEX_CHECK_STATUS; 1247 } 1248 1249 // 1250 // Stack Limits 1251 // 1252 { 1253 UErrorCode status = U_ZERO_ERROR; 1254 UnicodeString testString(1000000, 0x41, 1000000); // Length 1,000,000, filled with 'A' 1255 1256 // Adding the capturing parentheses to the pattern "(A)+A$" inhibits optimizations 1257 // of the '+', and makes the stack frames larger. 1258 RegexMatcher matcher("(A)+A$", testString, 0, status); 1259 1260 // With the default stack, this match should fail to run 1261 REGEX_ASSERT(matcher.lookingAt(status) == FALSE); 1262 REGEX_ASSERT(status == U_REGEX_STACK_OVERFLOW); 1263 1264 // With unlimited stack, it should run 1265 status = U_ZERO_ERROR; 1266 matcher.setStackLimit(0, status); 1267 REGEX_CHECK_STATUS; 1268 REGEX_ASSERT(matcher.lookingAt(status) == TRUE); 1269 REGEX_CHECK_STATUS; 1270 REGEX_ASSERT(matcher.getStackLimit() == 0); 1271 1272 // With a limited stack, it the match should fail 1273 status = U_ZERO_ERROR; 1274 matcher.setStackLimit(10000, status); 1275 REGEX_ASSERT(matcher.lookingAt(status) == FALSE); 1276 REGEX_ASSERT(status == U_REGEX_STACK_OVERFLOW); 1277 REGEX_ASSERT(matcher.getStackLimit() == 10000); 1278 } 1279 1280 // A pattern that doesn't save state should work with 1281 // a minimal sized stack 1282 { 1283 UErrorCode status = U_ZERO_ERROR; 1284 UnicodeString testString = "abc"; 1285 RegexMatcher matcher("abc", testString, 0, status); 1286 REGEX_CHECK_STATUS; 1287 matcher.setStackLimit(30, status); 1288 REGEX_CHECK_STATUS; 1289 REGEX_ASSERT(matcher.matches(status) == TRUE); 1290 REGEX_CHECK_STATUS; 1291 REGEX_ASSERT(matcher.getStackLimit() == 30); 1292 1293 // Negative stack sizes should fail 1294 status = U_ZERO_ERROR; 1295 matcher.setStackLimit(1000, status); 1296 REGEX_CHECK_STATUS; 1297 matcher.setStackLimit(-1, status); 1298 REGEX_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 1299 REGEX_ASSERT(matcher.getStackLimit() == 1000); 1300 } 1301 1302 1303 } 1304 1305 1306 1307 1308 1309 1310 //--------------------------------------------------------------------------- 1311 // 1312 // API_Replace API test for class RegexMatcher, testing the 1313 // Replace family of functions. 1314 // 1315 //--------------------------------------------------------------------------- 1316 void RegexTest::API_Replace() { 1317 // 1318 // Replace 1319 // 1320 int32_t flags=0; 1321 UParseError pe; 1322 UErrorCode status=U_ZERO_ERROR; 1323 1324 UnicodeString re("abc"); 1325 RegexPattern *pat = RegexPattern::compile(re, flags, pe, status); 1326 REGEX_CHECK_STATUS; 1327 UnicodeString data = ".abc..abc...abc.."; 1328 // 012345678901234567 1329 RegexMatcher *matcher = pat->matcher(data, status); 1330 1331 // 1332 // Plain vanilla matches. 1333 // 1334 UnicodeString dest; 1335 dest = matcher->replaceFirst("yz", status); 1336 REGEX_CHECK_STATUS; 1337 REGEX_ASSERT(dest == ".yz..abc...abc.."); 1338 1339 dest = matcher->replaceAll("yz", status); 1340 REGEX_CHECK_STATUS; 1341 REGEX_ASSERT(dest == ".yz..yz...yz.."); 1342 1343 // 1344 // Plain vanilla non-matches. 1345 // 1346 UnicodeString d2 = ".abx..abx...abx.."; 1347 matcher->reset(d2); 1348 dest = matcher->replaceFirst("yz", status); 1349 REGEX_CHECK_STATUS; 1350 REGEX_ASSERT(dest == ".abx..abx...abx.."); 1351 1352 dest = matcher->replaceAll("yz", status); 1353 REGEX_CHECK_STATUS; 1354 REGEX_ASSERT(dest == ".abx..abx...abx.."); 1355 1356 // 1357 // Empty source string 1358 // 1359 UnicodeString d3 = ""; 1360 matcher->reset(d3); 1361 dest = matcher->replaceFirst("yz", status); 1362 REGEX_CHECK_STATUS; 1363 REGEX_ASSERT(dest == ""); 1364 1365 dest = matcher->replaceAll("yz", status); 1366 REGEX_CHECK_STATUS; 1367 REGEX_ASSERT(dest == ""); 1368 1369 // 1370 // Empty substitution string 1371 // 1372 matcher->reset(data); // ".abc..abc...abc.." 1373 dest = matcher->replaceFirst("", status); 1374 REGEX_CHECK_STATUS; 1375 REGEX_ASSERT(dest == "...abc...abc.."); 1376 1377 dest = matcher->replaceAll("", status); 1378 REGEX_CHECK_STATUS; 1379 REGEX_ASSERT(dest == "........"); 1380 1381 // 1382 // match whole string 1383 // 1384 UnicodeString d4 = "abc"; 1385 matcher->reset(d4); 1386 dest = matcher->replaceFirst("xyz", status); 1387 REGEX_CHECK_STATUS; 1388 REGEX_ASSERT(dest == "xyz"); 1389 1390 dest = matcher->replaceAll("xyz", status); 1391 REGEX_CHECK_STATUS; 1392 REGEX_ASSERT(dest == "xyz"); 1393 1394 // 1395 // Capture Group, simple case 1396 // 1397 UnicodeString re2("a(..)"); 1398 RegexPattern *pat2 = RegexPattern::compile(re2, flags, pe, status); 1399 REGEX_CHECK_STATUS; 1400 UnicodeString d5 = "abcdefg"; 1401 RegexMatcher *matcher2 = pat2->matcher(d5, status); 1402 REGEX_CHECK_STATUS; 1403 dest = matcher2->replaceFirst("$1$1", status); 1404 REGEX_CHECK_STATUS; 1405 REGEX_ASSERT(dest == "bcbcdefg"); 1406 1407 dest = matcher2->replaceFirst(UNICODE_STRING_SIMPLE("The value of \\$1 is $1."), status); 1408 REGEX_CHECK_STATUS; 1409 REGEX_ASSERT(dest == "The value of $1 is bc.defg"); 1410 1411 dest = matcher2->replaceFirst("$ by itself, no group number $$$", status); 1412 REGEX_CHECK_STATUS; 1413 REGEX_ASSERT(dest == "$ by itself, no group number $$$defg"); 1414 1415 UnicodeString replacement = UNICODE_STRING_SIMPLE("Supplemental Digit 1 $\\U0001D7CF."); 1416 replacement = replacement.unescape(); 1417 dest = matcher2->replaceFirst(replacement, status); 1418 REGEX_CHECK_STATUS; 1419 REGEX_ASSERT(dest == "Supplemental Digit 1 bc.defg"); 1420 1421 REGEX_ASSERT_FAIL(matcher2->replaceFirst("bad capture group number $5...",status), U_INDEX_OUTOFBOUNDS_ERROR); 1422 1423 1424 // 1425 // Replacement String with \u hex escapes 1426 // 1427 { 1428 UnicodeString src = "abc 1 abc 2 abc 3"; 1429 UnicodeString substitute = UNICODE_STRING_SIMPLE("--\\u0043--"); 1430 matcher->reset(src); 1431 UnicodeString result = matcher->replaceAll(substitute, status); 1432 REGEX_CHECK_STATUS; 1433 REGEX_ASSERT(result == "--C-- 1 --C-- 2 --C-- 3"); 1434 } 1435 { 1436 UnicodeString src = "abc !"; 1437 UnicodeString substitute = UNICODE_STRING_SIMPLE("--\\U00010000--"); 1438 matcher->reset(src); 1439 UnicodeString result = matcher->replaceAll(substitute, status); 1440 REGEX_CHECK_STATUS; 1441 UnicodeString expected = UnicodeString("--"); 1442 expected.append((UChar32)0x10000); 1443 expected.append("-- !"); 1444 REGEX_ASSERT(result == expected); 1445 } 1446 // TODO: need more through testing of capture substitutions. 1447 1448 // Bug 4057 1449 // 1450 { 1451 status = U_ZERO_ERROR; 1452 UnicodeString s = "The matches start with ss and end with ee ss stuff ee fin"; 1453 RegexMatcher m("ss(.*?)ee", 0, status); 1454 REGEX_CHECK_STATUS; 1455 UnicodeString result; 1456 1457 // Multiple finds do NOT bump up the previous appendReplacement postion. 1458 m.reset(s); 1459 m.find(); 1460 m.find(); 1461 m.appendReplacement(result, "ooh", status); 1462 REGEX_CHECK_STATUS; 1463 REGEX_ASSERT(result == "The matches start with ss and end with ee ooh"); 1464 1465 // After a reset into the interior of a string, appendReplacemnt still starts at beginning. 1466 status = U_ZERO_ERROR; 1467 result.truncate(0); 1468 m.reset(10, status); 1469 m.find(); 1470 m.find(); 1471 m.appendReplacement(result, "ooh", status); 1472 REGEX_CHECK_STATUS; 1473 REGEX_ASSERT(result == "The matches start with ss and end with ee ooh"); 1474 1475 // find() at interior of string, appendReplacemnt still starts at beginning. 1476 status = U_ZERO_ERROR; 1477 result.truncate(0); 1478 m.reset(); 1479 m.find(10, status); 1480 m.find(); 1481 m.appendReplacement(result, "ooh", status); 1482 REGEX_CHECK_STATUS; 1483 REGEX_ASSERT(result == "The matches start with ss and end with ee ooh"); 1484 1485 m.appendTail(result); 1486 REGEX_ASSERT(result == "The matches start with ss and end with ee ooh fin"); 1487 1488 } 1489 1490 delete matcher2; 1491 delete pat2; 1492 delete matcher; 1493 delete pat; 1494 } 1495 1496 1497 //--------------------------------------------------------------------------- 1498 // 1499 // API_Pattern Test that the API for class RegexPattern is 1500 // present and nominally working. 1501 // 1502 //--------------------------------------------------------------------------- 1503 void RegexTest::API_Pattern() { 1504 RegexPattern pata; // Test default constructor to not crash. 1505 RegexPattern patb; 1506 1507 REGEX_ASSERT(pata == patb); 1508 REGEX_ASSERT(pata == pata); 1509 1510 UnicodeString re1("abc[a-l][m-z]"); 1511 UnicodeString re2("def"); 1512 UErrorCode status = U_ZERO_ERROR; 1513 UParseError pe; 1514 1515 RegexPattern *pat1 = RegexPattern::compile(re1, 0, pe, status); 1516 RegexPattern *pat2 = RegexPattern::compile(re2, 0, pe, status); 1517 REGEX_CHECK_STATUS; 1518 REGEX_ASSERT(*pat1 == *pat1); 1519 REGEX_ASSERT(*pat1 != pata); 1520 1521 // Assign 1522 patb = *pat1; 1523 REGEX_ASSERT(patb == *pat1); 1524 1525 // Copy Construct 1526 RegexPattern patc(*pat1); 1527 REGEX_ASSERT(patc == *pat1); 1528 REGEX_ASSERT(patb == patc); 1529 REGEX_ASSERT(pat1 != pat2); 1530 patb = *pat2; 1531 REGEX_ASSERT(patb != patc); 1532 REGEX_ASSERT(patb == *pat2); 1533 1534 // Compile with no flags. 1535 RegexPattern *pat1a = RegexPattern::compile(re1, pe, status); 1536 REGEX_ASSERT(*pat1a == *pat1); 1537 1538 REGEX_ASSERT(pat1a->flags() == 0); 1539 1540 // Compile with different flags should be not equal 1541 RegexPattern *pat1b = RegexPattern::compile(re1, UREGEX_CASE_INSENSITIVE, pe, status); 1542 REGEX_CHECK_STATUS; 1543 1544 REGEX_ASSERT(*pat1b != *pat1a); 1545 REGEX_ASSERT(pat1b->flags() == UREGEX_CASE_INSENSITIVE); 1546 REGEX_ASSERT(pat1a->flags() == 0); 1547 delete pat1b; 1548 1549 // clone 1550 RegexPattern *pat1c = pat1->clone(); 1551 REGEX_ASSERT(*pat1c == *pat1); 1552 REGEX_ASSERT(*pat1c != *pat2); 1553 1554 delete pat1c; 1555 delete pat1a; 1556 delete pat1; 1557 delete pat2; 1558 1559 1560 // 1561 // Verify that a matcher created from a cloned pattern works. 1562 // (Jitterbug 3423) 1563 // 1564 { 1565 UErrorCode status = U_ZERO_ERROR; 1566 RegexPattern *pSource = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\p{L}+"), 0, status); 1567 RegexPattern *pClone = pSource->clone(); 1568 delete pSource; 1569 RegexMatcher *mFromClone = pClone->matcher(status); 1570 REGEX_CHECK_STATUS; 1571 UnicodeString s = "Hello World"; 1572 mFromClone->reset(s); 1573 REGEX_ASSERT(mFromClone->find() == TRUE); 1574 REGEX_ASSERT(mFromClone->group(status) == "Hello"); 1575 REGEX_ASSERT(mFromClone->find() == TRUE); 1576 REGEX_ASSERT(mFromClone->group(status) == "World"); 1577 REGEX_ASSERT(mFromClone->find() == FALSE); 1578 delete mFromClone; 1579 delete pClone; 1580 } 1581 1582 // 1583 // matches convenience API 1584 // 1585 REGEX_ASSERT(RegexPattern::matches(".*", "random input", pe, status) == TRUE); 1586 REGEX_CHECK_STATUS; 1587 REGEX_ASSERT(RegexPattern::matches("abc", "random input", pe, status) == FALSE); 1588 REGEX_CHECK_STATUS; 1589 REGEX_ASSERT(RegexPattern::matches(".*nput", "random input", pe, status) == TRUE); 1590 REGEX_CHECK_STATUS; 1591 REGEX_ASSERT(RegexPattern::matches("random input", "random input", pe, status) == TRUE); 1592 REGEX_CHECK_STATUS; 1593 REGEX_ASSERT(RegexPattern::matches(".*u", "random input", pe, status) == FALSE); 1594 REGEX_CHECK_STATUS; 1595 status = U_INDEX_OUTOFBOUNDS_ERROR; 1596 REGEX_ASSERT(RegexPattern::matches("abc", "abc", pe, status) == FALSE); 1597 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1598 1599 1600 // 1601 // Split() 1602 // 1603 status = U_ZERO_ERROR; 1604 pat1 = RegexPattern::compile(" +", pe, status); 1605 REGEX_CHECK_STATUS; 1606 UnicodeString fields[10]; 1607 1608 int32_t n; 1609 n = pat1->split("Now is the time", fields, 10, status); 1610 REGEX_CHECK_STATUS; 1611 REGEX_ASSERT(n==4); 1612 REGEX_ASSERT(fields[0]=="Now"); 1613 REGEX_ASSERT(fields[1]=="is"); 1614 REGEX_ASSERT(fields[2]=="the"); 1615 REGEX_ASSERT(fields[3]=="time"); 1616 REGEX_ASSERT(fields[4]==""); 1617 1618 n = pat1->split("Now is the time", fields, 2, status); 1619 REGEX_CHECK_STATUS; 1620 REGEX_ASSERT(n==2); 1621 REGEX_ASSERT(fields[0]=="Now"); 1622 REGEX_ASSERT(fields[1]=="is the time"); 1623 REGEX_ASSERT(fields[2]=="the"); // left over from previous test 1624 1625 fields[1] = "*"; 1626 status = U_ZERO_ERROR; 1627 n = pat1->split("Now is the time", fields, 1, status); 1628 REGEX_CHECK_STATUS; 1629 REGEX_ASSERT(n==1); 1630 REGEX_ASSERT(fields[0]=="Now is the time"); 1631 REGEX_ASSERT(fields[1]=="*"); 1632 status = U_ZERO_ERROR; 1633 1634 n = pat1->split(" Now is the time ", fields, 10, status); 1635 REGEX_CHECK_STATUS; 1636 REGEX_ASSERT(n==6); 1637 REGEX_ASSERT(fields[0]==""); 1638 REGEX_ASSERT(fields[1]=="Now"); 1639 REGEX_ASSERT(fields[2]=="is"); 1640 REGEX_ASSERT(fields[3]=="the"); 1641 REGEX_ASSERT(fields[4]=="time"); 1642 REGEX_ASSERT(fields[5]==""); 1643 1644 n = pat1->split(" ", fields, 10, status); 1645 REGEX_CHECK_STATUS; 1646 REGEX_ASSERT(n==2); 1647 REGEX_ASSERT(fields[0]==""); 1648 REGEX_ASSERT(fields[1]==""); 1649 1650 fields[0] = "foo"; 1651 n = pat1->split("", fields, 10, status); 1652 REGEX_CHECK_STATUS; 1653 REGEX_ASSERT(n==0); 1654 REGEX_ASSERT(fields[0]=="foo"); 1655 1656 delete pat1; 1657 1658 // split, with a pattern with (capture) 1659 pat1 = RegexPattern::compile(UNICODE_STRING_SIMPLE("<(\\w*)>"), pe, status); 1660 REGEX_CHECK_STATUS; 1661 1662 status = U_ZERO_ERROR; 1663 n = pat1->split("<a>Now is <b>the time<c>", fields, 10, status); 1664 REGEX_CHECK_STATUS; 1665 REGEX_ASSERT(n==7); 1666 REGEX_ASSERT(fields[0]==""); 1667 REGEX_ASSERT(fields[1]=="a"); 1668 REGEX_ASSERT(fields[2]=="Now is "); 1669 REGEX_ASSERT(fields[3]=="b"); 1670 REGEX_ASSERT(fields[4]=="the time"); 1671 REGEX_ASSERT(fields[5]=="c"); 1672 REGEX_ASSERT(fields[6]==""); 1673 REGEX_ASSERT(status==U_ZERO_ERROR); 1674 1675 n = pat1->split(" <a>Now is <b>the time<c>", fields, 10, status); 1676 REGEX_CHECK_STATUS; 1677 REGEX_ASSERT(n==7); 1678 REGEX_ASSERT(fields[0]==" "); 1679 REGEX_ASSERT(fields[1]=="a"); 1680 REGEX_ASSERT(fields[2]=="Now is "); 1681 REGEX_ASSERT(fields[3]=="b"); 1682 REGEX_ASSERT(fields[4]=="the time"); 1683 REGEX_ASSERT(fields[5]=="c"); 1684 REGEX_ASSERT(fields[6]==""); 1685 1686 status = U_ZERO_ERROR; 1687 fields[6] = "foo"; 1688 n = pat1->split(" <a>Now is <b>the time<c>", fields, 6, status); 1689 REGEX_CHECK_STATUS; 1690 REGEX_ASSERT(n==6); 1691 REGEX_ASSERT(fields[0]==" "); 1692 REGEX_ASSERT(fields[1]=="a"); 1693 REGEX_ASSERT(fields[2]=="Now is "); 1694 REGEX_ASSERT(fields[3]=="b"); 1695 REGEX_ASSERT(fields[4]=="the time"); 1696 REGEX_ASSERT(fields[5]==""); // All text following "<c>" field delimiter. 1697 REGEX_ASSERT(fields[6]=="foo"); 1698 1699 status = U_ZERO_ERROR; 1700 fields[5] = "foo"; 1701 n = pat1->split(" <a>Now is <b>the time<c>", fields, 5, status); 1702 REGEX_CHECK_STATUS; 1703 REGEX_ASSERT(n==5); 1704 REGEX_ASSERT(fields[0]==" "); 1705 REGEX_ASSERT(fields[1]=="a"); 1706 REGEX_ASSERT(fields[2]=="Now is "); 1707 REGEX_ASSERT(fields[3]=="b"); 1708 REGEX_ASSERT(fields[4]=="the time<c>"); 1709 REGEX_ASSERT(fields[5]=="foo"); 1710 1711 status = U_ZERO_ERROR; 1712 fields[5] = "foo"; 1713 n = pat1->split(" <a>Now is <b>the time", fields, 5, status); 1714 REGEX_CHECK_STATUS; 1715 REGEX_ASSERT(n==5); 1716 REGEX_ASSERT(fields[0]==" "); 1717 REGEX_ASSERT(fields[1]=="a"); 1718 REGEX_ASSERT(fields[2]=="Now is "); 1719 REGEX_ASSERT(fields[3]=="b"); 1720 REGEX_ASSERT(fields[4]=="the time"); 1721 REGEX_ASSERT(fields[5]=="foo"); 1722 1723 status = U_ZERO_ERROR; 1724 n = pat1->split(" <a>Now is <b>the time<c>", fields, 4, status); 1725 REGEX_CHECK_STATUS; 1726 REGEX_ASSERT(n==4); 1727 REGEX_ASSERT(fields[0]==" "); 1728 REGEX_ASSERT(fields[1]=="a"); 1729 REGEX_ASSERT(fields[2]=="Now is "); 1730 REGEX_ASSERT(fields[3]=="the time<c>"); 1731 status = U_ZERO_ERROR; 1732 delete pat1; 1733 1734 pat1 = RegexPattern::compile("([-,])", pe, status); 1735 REGEX_CHECK_STATUS; 1736 n = pat1->split("1-10,20", fields, 10, status); 1737 REGEX_CHECK_STATUS; 1738 REGEX_ASSERT(n==5); 1739 REGEX_ASSERT(fields[0]=="1"); 1740 REGEX_ASSERT(fields[1]=="-"); 1741 REGEX_ASSERT(fields[2]=="10"); 1742 REGEX_ASSERT(fields[3]==","); 1743 REGEX_ASSERT(fields[4]=="20"); 1744 delete pat1; 1745 1746 // Test split of string with empty trailing fields 1747 pat1 = RegexPattern::compile(",", pe, status); 1748 REGEX_CHECK_STATUS; 1749 n = pat1->split("a,b,c,", fields, 10, status); 1750 REGEX_CHECK_STATUS; 1751 REGEX_ASSERT(n==4); 1752 REGEX_ASSERT(fields[0]=="a"); 1753 REGEX_ASSERT(fields[1]=="b"); 1754 REGEX_ASSERT(fields[2]=="c"); 1755 REGEX_ASSERT(fields[3]==""); 1756 1757 n = pat1->split("a,,,", fields, 10, status); 1758 REGEX_CHECK_STATUS; 1759 REGEX_ASSERT(n==4); 1760 REGEX_ASSERT(fields[0]=="a"); 1761 REGEX_ASSERT(fields[1]==""); 1762 REGEX_ASSERT(fields[2]==""); 1763 REGEX_ASSERT(fields[3]==""); 1764 delete pat1; 1765 1766 // Split Separator with zero length match. 1767 pat1 = RegexPattern::compile(":?", pe, status); 1768 REGEX_CHECK_STATUS; 1769 n = pat1->split("abc", fields, 10, status); 1770 REGEX_CHECK_STATUS; 1771 REGEX_ASSERT(n==5); 1772 REGEX_ASSERT(fields[0]==""); 1773 REGEX_ASSERT(fields[1]=="a"); 1774 REGEX_ASSERT(fields[2]=="b"); 1775 REGEX_ASSERT(fields[3]=="c"); 1776 REGEX_ASSERT(fields[4]==""); 1777 1778 delete pat1; 1779 1780 // 1781 // RegexPattern::pattern() 1782 // 1783 pat1 = new RegexPattern(); 1784 REGEX_ASSERT(pat1->pattern() == ""); 1785 delete pat1; 1786 1787 pat1 = RegexPattern::compile("(Hello, world)*", pe, status); 1788 REGEX_CHECK_STATUS; 1789 REGEX_ASSERT(pat1->pattern() == "(Hello, world)*"); 1790 delete pat1; 1791 1792 1793 // 1794 // classID functions 1795 // 1796 pat1 = RegexPattern::compile("(Hello, world)*", pe, status); 1797 REGEX_CHECK_STATUS; 1798 REGEX_ASSERT(pat1->getDynamicClassID() == RegexPattern::getStaticClassID()); 1799 REGEX_ASSERT(pat1->getDynamicClassID() != NULL); 1800 UnicodeString Hello("Hello, world."); 1801 RegexMatcher *m = pat1->matcher(Hello, status); 1802 REGEX_ASSERT(pat1->getDynamicClassID() != m->getDynamicClassID()); 1803 REGEX_ASSERT(m->getDynamicClassID() == RegexMatcher::getStaticClassID()); 1804 REGEX_ASSERT(m->getDynamicClassID() != NULL); 1805 delete m; 1806 delete pat1; 1807 1808 } 1809 1810 //--------------------------------------------------------------------------- 1811 // 1812 // API_Match_UTF8 Test that the alternate engine for class RegexMatcher 1813 // is present and working, but excluding functions 1814 // implementing replace operations. 1815 // 1816 //--------------------------------------------------------------------------- 1817 void RegexTest::API_Match_UTF8() { 1818 UParseError pe; 1819 UErrorCode status=U_ZERO_ERROR; 1820 int32_t flags = 0; 1821 1822 // 1823 // Debug - slide failing test cases early 1824 // 1825 #if 0 1826 { 1827 } 1828 return; 1829 #endif 1830 1831 // 1832 // Simple pattern compilation 1833 // 1834 { 1835 UText re = UTEXT_INITIALIZER; 1836 regextst_openUTF8FromInvariant(&re, "abc", -1, &status); 1837 REGEX_VERBOSE_TEXT(&re); 1838 RegexPattern *pat2; 1839 pat2 = RegexPattern::compile(&re, flags, pe, status); 1840 REGEX_CHECK_STATUS; 1841 1842 UText input1 = UTEXT_INITIALIZER; 1843 UText input2 = UTEXT_INITIALIZER; 1844 UText empty = UTEXT_INITIALIZER; 1845 regextst_openUTF8FromInvariant(&input1, "abcdef this is a test", -1, &status); 1846 REGEX_VERBOSE_TEXT(&input1); 1847 regextst_openUTF8FromInvariant(&input2, "not abc", -1, &status); 1848 REGEX_VERBOSE_TEXT(&input2); 1849 utext_openUChars(&empty, NULL, 0, &status); 1850 1851 int32_t input1Len = strlen("abcdef this is a test"); /* TODO: why not nativelen (input1) ? */ 1852 int32_t input2Len = strlen("not abc"); 1853 1854 1855 // 1856 // Matcher creation and reset. 1857 // 1858 RegexMatcher *m1 = &pat2->matcher(status)->reset(&input1); 1859 REGEX_CHECK_STATUS; 1860 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 1861 const char str_abcdefthisisatest[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x00 }; /* abcdef this is a test */ 1862 REGEX_ASSERT_UTEXT_UTF8(str_abcdefthisisatest, m1->inputText()); 1863 m1->reset(&input2); 1864 REGEX_ASSERT(m1->lookingAt(status) == FALSE); 1865 const char str_notabc[] = { 0x6e, 0x6f, 0x74, 0x20, 0x61, 0x62, 0x63, 0x00 }; /* not abc */ 1866 REGEX_ASSERT_UTEXT_UTF8(str_notabc, m1->inputText()); 1867 m1->reset(&input1); 1868 REGEX_ASSERT_UTEXT_UTF8(str_abcdefthisisatest, m1->inputText()); 1869 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 1870 m1->reset(&empty); 1871 REGEX_ASSERT(m1->lookingAt(status) == FALSE); 1872 REGEX_ASSERT(utext_nativeLength(&empty) == 0); 1873 1874 // 1875 // reset(pos, status) 1876 // 1877 m1->reset(&input1); 1878 m1->reset(4, status); 1879 REGEX_CHECK_STATUS; 1880 REGEX_ASSERT_UTEXT_UTF8(str_abcdefthisisatest, m1->inputText()); 1881 REGEX_ASSERT(m1->lookingAt(status) == TRUE); 1882 1883 m1->reset(-1, status); 1884 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1885 status = U_ZERO_ERROR; 1886 1887 m1->reset(0, status); 1888 REGEX_CHECK_STATUS; 1889 status = U_ZERO_ERROR; 1890 1891 m1->reset(input1Len-1, status); 1892 REGEX_CHECK_STATUS; 1893 status = U_ZERO_ERROR; 1894 1895 m1->reset(input1Len, status); 1896 REGEX_CHECK_STATUS; 1897 status = U_ZERO_ERROR; 1898 1899 m1->reset(input1Len+1, status); 1900 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1901 status = U_ZERO_ERROR; 1902 1903 // 1904 // match(pos, status) 1905 // 1906 m1->reset(&input2); 1907 REGEX_ASSERT(m1->matches(4, status) == TRUE); 1908 m1->reset(); 1909 REGEX_ASSERT(m1->matches(3, status) == FALSE); 1910 m1->reset(); 1911 REGEX_ASSERT(m1->matches(5, status) == FALSE); 1912 REGEX_ASSERT(m1->matches(4, status) == TRUE); 1913 REGEX_ASSERT(m1->matches(-1, status) == FALSE); 1914 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1915 1916 // Match() at end of string should fail, but should not 1917 // be an error. 1918 status = U_ZERO_ERROR; 1919 REGEX_ASSERT(m1->matches(input2Len, status) == FALSE); 1920 REGEX_CHECK_STATUS; 1921 1922 // Match beyond end of string should fail with an error. 1923 status = U_ZERO_ERROR; 1924 REGEX_ASSERT(m1->matches(input2Len+1, status) == FALSE); 1925 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1926 1927 // Successful match at end of string. 1928 { 1929 status = U_ZERO_ERROR; 1930 RegexMatcher m("A?", 0, status); // will match zero length string. 1931 REGEX_CHECK_STATUS; 1932 m.reset(&input1); 1933 REGEX_ASSERT(m.matches(input1Len, status) == TRUE); 1934 REGEX_CHECK_STATUS; 1935 m.reset(&empty); 1936 REGEX_ASSERT(m.matches(0, status) == TRUE); 1937 REGEX_CHECK_STATUS; 1938 } 1939 1940 1941 // 1942 // lookingAt(pos, status) 1943 // 1944 status = U_ZERO_ERROR; 1945 m1->reset(&input2); // "not abc" 1946 REGEX_ASSERT(m1->lookingAt(4, status) == TRUE); 1947 REGEX_ASSERT(m1->lookingAt(5, status) == FALSE); 1948 REGEX_ASSERT(m1->lookingAt(3, status) == FALSE); 1949 REGEX_ASSERT(m1->lookingAt(4, status) == TRUE); 1950 REGEX_ASSERT(m1->lookingAt(-1, status) == FALSE); 1951 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1952 status = U_ZERO_ERROR; 1953 REGEX_ASSERT(m1->lookingAt(input2Len, status) == FALSE); 1954 REGEX_CHECK_STATUS; 1955 REGEX_ASSERT(m1->lookingAt(input2Len+1, status) == FALSE); 1956 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 1957 1958 delete m1; 1959 delete pat2; 1960 1961 utext_close(&re); 1962 utext_close(&input1); 1963 utext_close(&input2); 1964 utext_close(&empty); 1965 } 1966 1967 1968 // 1969 // Capture Group. 1970 // RegexMatcher::start(); 1971 // RegexMatcher::end(); 1972 // RegexMatcher::groupCount(); 1973 // 1974 { 1975 int32_t flags=0; 1976 UParseError pe; 1977 UErrorCode status=U_ZERO_ERROR; 1978 UText re=UTEXT_INITIALIZER; 1979 const char str_01234567_pat[] = { 0x30, 0x31, 0x28, 0x32, 0x33, 0x28, 0x34, 0x35, 0x29, 0x36, 0x37, 0x29, 0x28, 0x2e, 0x2a, 0x29, 0x00 }; /* 01(23(45)67)(.*) */ 1980 utext_openUTF8(&re, str_01234567_pat, -1, &status); 1981 1982 RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status); 1983 REGEX_CHECK_STATUS; 1984 1985 UText input = UTEXT_INITIALIZER; 1986 const char str_0123456789[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00 }; /* 0123456789 */ 1987 utext_openUTF8(&input, str_0123456789, -1, &status); 1988 1989 RegexMatcher *matcher = &pat->matcher(status)->reset(&input); 1990 REGEX_CHECK_STATUS; 1991 REGEX_ASSERT(matcher->lookingAt(status) == TRUE); 1992 static const int32_t matchStarts[] = {0, 2, 4, 8}; 1993 static const int32_t matchEnds[] = {10, 8, 6, 10}; 1994 int32_t i; 1995 for (i=0; i<4; i++) { 1996 int32_t actualStart = matcher->start(i, status); 1997 REGEX_CHECK_STATUS; 1998 if (actualStart != matchStarts[i]) { 1999 errln("RegexTest failure at %s:%d, index %d. Expected %d, got %d\n", 2000 __FILE__, __LINE__, i, matchStarts[i], actualStart); 2001 } 2002 int32_t actualEnd = matcher->end(i, status); 2003 REGEX_CHECK_STATUS; 2004 if (actualEnd != matchEnds[i]) { 2005 errln("RegexTest failure at %s:%d index %d. Expected %d, got %d\n", 2006 __FILE__, __LINE__, i, matchEnds[i], actualEnd); 2007 } 2008 } 2009 2010 REGEX_ASSERT(matcher->start(0, status) == matcher->start(status)); 2011 REGEX_ASSERT(matcher->end(0, status) == matcher->end(status)); 2012 2013 REGEX_ASSERT_FAIL(matcher->start(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 2014 REGEX_ASSERT_FAIL(matcher->start( 4, status), U_INDEX_OUTOFBOUNDS_ERROR); 2015 matcher->reset(); 2016 REGEX_ASSERT_FAIL(matcher->start( 0, status), U_REGEX_INVALID_STATE); 2017 2018 matcher->lookingAt(status); 2019 2020 UnicodeString dest; 2021 UText destText = UTEXT_INITIALIZER; 2022 utext_openUnicodeString(&destText, &dest, &status); 2023 UText *result; 2024 //const char str_0123456789[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00 }; /* 0123456789 */ 2025 // Test shallow-clone API 2026 int64_t group_len; 2027 result = matcher->group((UText *)NULL, group_len, status); 2028 REGEX_CHECK_STATUS; 2029 REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result); 2030 utext_close(result); 2031 result = matcher->group(0, &destText, group_len, status); 2032 REGEX_CHECK_STATUS; 2033 REGEX_ASSERT(result == &destText); 2034 REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result); 2035 // destText is now immutable, reopen it 2036 utext_close(&destText); 2037 utext_openUnicodeString(&destText, &dest, &status); 2038 2039 result = matcher->group(0, NULL, status); 2040 REGEX_CHECK_STATUS; 2041 REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result); 2042 utext_close(result); 2043 result = matcher->group(0, &destText, status); 2044 REGEX_CHECK_STATUS; 2045 REGEX_ASSERT(result == &destText); 2046 REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result); 2047 2048 result = matcher->group(1, NULL, status); 2049 REGEX_CHECK_STATUS; 2050 const char str_234567[] = { 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x00 }; /* 234567 */ 2051 REGEX_ASSERT_UTEXT_UTF8(str_234567, result); 2052 utext_close(result); 2053 result = matcher->group(1, &destText, status); 2054 REGEX_CHECK_STATUS; 2055 REGEX_ASSERT(result == &destText); 2056 REGEX_ASSERT_UTEXT_UTF8(str_234567, result); 2057 2058 result = matcher->group(2, NULL, status); 2059 REGEX_CHECK_STATUS; 2060 const char str_45[] = { 0x34, 0x35, 0x00 }; /* 45 */ 2061 REGEX_ASSERT_UTEXT_UTF8(str_45, result); 2062 utext_close(result); 2063 result = matcher->group(2, &destText, status); 2064 REGEX_CHECK_STATUS; 2065 REGEX_ASSERT(result == &destText); 2066 REGEX_ASSERT_UTEXT_UTF8(str_45, result); 2067 2068 result = matcher->group(3, NULL, status); 2069 REGEX_CHECK_STATUS; 2070 const char str_89[] = { 0x38, 0x39, 0x00 }; /* 89 */ 2071 REGEX_ASSERT_UTEXT_UTF8(str_89, result); 2072 utext_close(result); 2073 result = matcher->group(3, &destText, status); 2074 REGEX_CHECK_STATUS; 2075 REGEX_ASSERT(result == &destText); 2076 REGEX_ASSERT_UTEXT_UTF8(str_89, result); 2077 2078 REGEX_ASSERT_FAIL(matcher->group(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 2079 REGEX_ASSERT_FAIL(matcher->group( 4, status), U_INDEX_OUTOFBOUNDS_ERROR); 2080 matcher->reset(); 2081 REGEX_ASSERT_FAIL(matcher->group( 0, status), U_REGEX_INVALID_STATE); 2082 2083 delete matcher; 2084 delete pat; 2085 2086 utext_close(&destText); 2087 utext_close(&input); 2088 utext_close(&re); 2089 } 2090 2091 // 2092 // find 2093 // 2094 { 2095 int32_t flags=0; 2096 UParseError pe; 2097 UErrorCode status=U_ZERO_ERROR; 2098 UText re=UTEXT_INITIALIZER; 2099 const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */ 2100 utext_openUTF8(&re, str_abc, -1, &status); 2101 2102 RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status); 2103 REGEX_CHECK_STATUS; 2104 UText input = UTEXT_INITIALIZER; 2105 const char str_abcabcabc[] = { 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .abc..abc...abc.. */ 2106 utext_openUTF8(&input, str_abcabcabc, -1, &status); 2107 // 012345678901234567 2108 2109 RegexMatcher *matcher = &pat->matcher(status)->reset(&input); 2110 REGEX_CHECK_STATUS; 2111 REGEX_ASSERT(matcher->find()); 2112 REGEX_ASSERT(matcher->start(status) == 1); 2113 REGEX_ASSERT(matcher->find()); 2114 REGEX_ASSERT(matcher->start(status) == 6); 2115 REGEX_ASSERT(matcher->find()); 2116 REGEX_ASSERT(matcher->start(status) == 12); 2117 REGEX_ASSERT(matcher->find() == FALSE); 2118 REGEX_ASSERT(matcher->find() == FALSE); 2119 2120 matcher->reset(); 2121 REGEX_ASSERT(matcher->find()); 2122 REGEX_ASSERT(matcher->start(status) == 1); 2123 2124 REGEX_ASSERT(matcher->find(0, status)); 2125 REGEX_ASSERT(matcher->start(status) == 1); 2126 REGEX_ASSERT(matcher->find(1, status)); 2127 REGEX_ASSERT(matcher->start(status) == 1); 2128 REGEX_ASSERT(matcher->find(2, status)); 2129 REGEX_ASSERT(matcher->start(status) == 6); 2130 REGEX_ASSERT(matcher->find(12, status)); 2131 REGEX_ASSERT(matcher->start(status) == 12); 2132 REGEX_ASSERT(matcher->find(13, status) == FALSE); 2133 REGEX_ASSERT(matcher->find(16, status) == FALSE); 2134 REGEX_ASSERT(matcher->find(17, status) == FALSE); 2135 REGEX_ASSERT_FAIL(matcher->start(status), U_REGEX_INVALID_STATE); 2136 2137 status = U_ZERO_ERROR; 2138 REGEX_ASSERT_FAIL(matcher->find(-1, status), U_INDEX_OUTOFBOUNDS_ERROR); 2139 status = U_ZERO_ERROR; 2140 REGEX_ASSERT_FAIL(matcher->find(18, status), U_INDEX_OUTOFBOUNDS_ERROR); 2141 2142 REGEX_ASSERT(matcher->groupCount() == 0); 2143 2144 delete matcher; 2145 delete pat; 2146 2147 utext_close(&input); 2148 utext_close(&re); 2149 } 2150 2151 2152 // 2153 // find, with \G in pattern (true if at the end of a previous match). 2154 // 2155 { 2156 int32_t flags=0; 2157 UParseError pe; 2158 UErrorCode status=U_ZERO_ERROR; 2159 UText re=UTEXT_INITIALIZER; 2160 const char str_Gabcabc[] = { 0x2e, 0x2a, 0x3f, 0x28, 0x3f, 0x3a, 0x28, 0x5c, 0x47, 0x61, 0x62, 0x63, 0x29, 0x7c, 0x28, 0x61, 0x62, 0x63, 0x29, 0x29, 0x00 }; /* .*?(?:(\\Gabc)|(abc)) */ 2161 utext_openUTF8(&re, str_Gabcabc, -1, &status); 2162 2163 RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status); 2164 2165 REGEX_CHECK_STATUS; 2166 UText input = UTEXT_INITIALIZER; 2167 const char str_abcabcabc[] = { 0x2e, 0x61, 0x62, 0x63, 0x61, 0x62, 0x63, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .abcabc.abc.. */ 2168 utext_openUTF8(&input, str_abcabcabc, -1, &status); 2169 // 012345678901234567 2170 2171 RegexMatcher *matcher = &pat->matcher(status)->reset(&input); 2172 REGEX_CHECK_STATUS; 2173 REGEX_ASSERT(matcher->find()); 2174 REGEX_ASSERT(matcher->start(status) == 0); 2175 REGEX_ASSERT(matcher->start(1, status) == -1); 2176 REGEX_ASSERT(matcher->start(2, status) == 1); 2177 2178 REGEX_ASSERT(matcher->find()); 2179 REGEX_ASSERT(matcher->start(status) == 4); 2180 REGEX_ASSERT(matcher->start(1, status) == 4); 2181 REGEX_ASSERT(matcher->start(2, status) == -1); 2182 REGEX_CHECK_STATUS; 2183 2184 delete matcher; 2185 delete pat; 2186 2187 utext_close(&input); 2188 utext_close(&re); 2189 } 2190 2191 // 2192 // find with zero length matches, match position should bump ahead 2193 // to prevent loops. 2194 // 2195 { 2196 int32_t i; 2197 UErrorCode status=U_ZERO_ERROR; 2198 RegexMatcher m("(?= ?)", 0, status); // This pattern will zero-length matches anywhere, 2199 // using an always-true look-ahead. 2200 REGEX_CHECK_STATUS; 2201 UText s = UTEXT_INITIALIZER; 2202 utext_openUTF8(&s, " ", -1, &status); 2203 m.reset(&s); 2204 for (i=0; ; i++) { 2205 if (m.find() == FALSE) { 2206 break; 2207 } 2208 REGEX_ASSERT(m.start(status) == i); 2209 REGEX_ASSERT(m.end(status) == i); 2210 } 2211 REGEX_ASSERT(i==5); 2212 2213 // Check that the bump goes over characters outside the BMP OK 2214 // "\\U00010001\\U00010002\\U00010003\\U00010004".unescape()...in UTF-8 2215 unsigned char aboveBMP[] = {0xF0, 0x90, 0x80, 0x81, 0xF0, 0x90, 0x80, 0x82, 0xF0, 0x90, 0x80, 0x83, 0xF0, 0x90, 0x80, 0x84, 0x00}; 2216 utext_openUTF8(&s, (char *)aboveBMP, -1, &status); 2217 m.reset(&s); 2218 for (i=0; ; i+=4) { 2219 if (m.find() == FALSE) { 2220 break; 2221 } 2222 REGEX_ASSERT(m.start(status) == i); 2223 REGEX_ASSERT(m.end(status) == i); 2224 } 2225 REGEX_ASSERT(i==20); 2226 2227 utext_close(&s); 2228 } 2229 { 2230 // find() loop breaking test. 2231 // with pattern of /.?/, should see a series of one char matches, then a single 2232 // match of zero length at the end of the input string. 2233 int32_t i; 2234 UErrorCode status=U_ZERO_ERROR; 2235 RegexMatcher m(".?", 0, status); 2236 REGEX_CHECK_STATUS; 2237 UText s = UTEXT_INITIALIZER; 2238 utext_openUTF8(&s, " ", -1, &status); 2239 m.reset(&s); 2240 for (i=0; ; i++) { 2241 if (m.find() == FALSE) { 2242 break; 2243 } 2244 REGEX_ASSERT(m.start(status) == i); 2245 REGEX_ASSERT(m.end(status) == (i<4 ? i+1 : i)); 2246 } 2247 REGEX_ASSERT(i==5); 2248 2249 utext_close(&s); 2250 } 2251 2252 2253 // 2254 // Matchers with no input string behave as if they had an empty input string. 2255 // 2256 2257 { 2258 UErrorCode status = U_ZERO_ERROR; 2259 RegexMatcher m(".?", 0, status); 2260 REGEX_CHECK_STATUS; 2261 REGEX_ASSERT(m.find()); 2262 REGEX_ASSERT(m.start(status) == 0); 2263 REGEX_ASSERT(m.input() == ""); 2264 } 2265 { 2266 UErrorCode status = U_ZERO_ERROR; 2267 RegexPattern *p = RegexPattern::compile(".", 0, status); 2268 RegexMatcher *m = p->matcher(status); 2269 REGEX_CHECK_STATUS; 2270 2271 REGEX_ASSERT(m->find() == FALSE); 2272 REGEX_ASSERT(utext_nativeLength(m->inputText()) == 0); 2273 delete m; 2274 delete p; 2275 } 2276 2277 // 2278 // Regions 2279 // 2280 { 2281 UErrorCode status = U_ZERO_ERROR; 2282 UText testPattern = UTEXT_INITIALIZER; 2283 UText testText = UTEXT_INITIALIZER; 2284 regextst_openUTF8FromInvariant(&testPattern, ".*", -1, &status); 2285 REGEX_VERBOSE_TEXT(&testPattern); 2286 regextst_openUTF8FromInvariant(&testText, "This is test data", -1, &status); 2287 REGEX_VERBOSE_TEXT(&testText); 2288 2289 RegexMatcher m(&testPattern, &testText, 0, status); 2290 REGEX_CHECK_STATUS; 2291 REGEX_ASSERT(m.regionStart() == 0); 2292 REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("This is test data")); 2293 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 2294 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 2295 2296 m.region(2,4, status); 2297 REGEX_CHECK_STATUS; 2298 REGEX_ASSERT(m.matches(status)); 2299 REGEX_ASSERT(m.start(status)==2); 2300 REGEX_ASSERT(m.end(status)==4); 2301 REGEX_CHECK_STATUS; 2302 2303 m.reset(); 2304 REGEX_ASSERT(m.regionStart() == 0); 2305 REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("This is test data")); 2306 2307 regextst_openUTF8FromInvariant(&testText, "short", -1, &status); 2308 REGEX_VERBOSE_TEXT(&testText); 2309 m.reset(&testText); 2310 REGEX_ASSERT(m.regionStart() == 0); 2311 REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("short")); 2312 2313 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 2314 REGEX_ASSERT(&m == &m.useAnchoringBounds(FALSE)); 2315 REGEX_ASSERT(m.hasAnchoringBounds() == FALSE); 2316 REGEX_ASSERT(&m == &m.reset()); 2317 REGEX_ASSERT(m.hasAnchoringBounds() == FALSE); 2318 2319 REGEX_ASSERT(&m == &m.useAnchoringBounds(TRUE)); 2320 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 2321 REGEX_ASSERT(&m == &m.reset()); 2322 REGEX_ASSERT(m.hasAnchoringBounds() == TRUE); 2323 2324 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 2325 REGEX_ASSERT(&m == &m.useTransparentBounds(TRUE)); 2326 REGEX_ASSERT(m.hasTransparentBounds() == TRUE); 2327 REGEX_ASSERT(&m == &m.reset()); 2328 REGEX_ASSERT(m.hasTransparentBounds() == TRUE); 2329 2330 REGEX_ASSERT(&m == &m.useTransparentBounds(FALSE)); 2331 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 2332 REGEX_ASSERT(&m == &m.reset()); 2333 REGEX_ASSERT(m.hasTransparentBounds() == FALSE); 2334 2335 utext_close(&testText); 2336 utext_close(&testPattern); 2337 } 2338 2339 // 2340 // hitEnd() and requireEnd() 2341 // 2342 { 2343 UErrorCode status = U_ZERO_ERROR; 2344 UText testPattern = UTEXT_INITIALIZER; 2345 UText testText = UTEXT_INITIALIZER; 2346 const char str_[] = { 0x2e, 0x2a, 0x00 }; /* .* */ 2347 const char str_aabb[] = { 0x61, 0x61, 0x62, 0x62, 0x00 }; /* aabb */ 2348 utext_openUTF8(&testPattern, str_, -1, &status); 2349 utext_openUTF8(&testText, str_aabb, -1, &status); 2350 2351 RegexMatcher m1(&testPattern, &testText, 0, status); 2352 REGEX_ASSERT(m1.lookingAt(status) == TRUE); 2353 REGEX_ASSERT(m1.hitEnd() == TRUE); 2354 REGEX_ASSERT(m1.requireEnd() == FALSE); 2355 REGEX_CHECK_STATUS; 2356 2357 status = U_ZERO_ERROR; 2358 const char str_a[] = { 0x61, 0x2a, 0x00 }; /* a* */ 2359 utext_openUTF8(&testPattern, str_a, -1, &status); 2360 RegexMatcher m2(&testPattern, &testText, 0, status); 2361 REGEX_ASSERT(m2.lookingAt(status) == TRUE); 2362 REGEX_ASSERT(m2.hitEnd() == FALSE); 2363 REGEX_ASSERT(m2.requireEnd() == FALSE); 2364 REGEX_CHECK_STATUS; 2365 2366 status = U_ZERO_ERROR; 2367 const char str_dotstardollar[] = { 0x2e, 0x2a, 0x24, 0x00 }; /* .*$ */ 2368 utext_openUTF8(&testPattern, str_dotstardollar, -1, &status); 2369 RegexMatcher m3(&testPattern, &testText, 0, status); 2370 REGEX_ASSERT(m3.lookingAt(status) == TRUE); 2371 REGEX_ASSERT(m3.hitEnd() == TRUE); 2372 REGEX_ASSERT(m3.requireEnd() == TRUE); 2373 REGEX_CHECK_STATUS; 2374 2375 utext_close(&testText); 2376 utext_close(&testPattern); 2377 } 2378 } 2379 2380 2381 //--------------------------------------------------------------------------- 2382 // 2383 // API_Replace_UTF8 API test for class RegexMatcher, testing the 2384 // Replace family of functions. 2385 // 2386 //--------------------------------------------------------------------------- 2387 void RegexTest::API_Replace_UTF8() { 2388 // 2389 // Replace 2390 // 2391 int32_t flags=0; 2392 UParseError pe; 2393 UErrorCode status=U_ZERO_ERROR; 2394 2395 UText re=UTEXT_INITIALIZER; 2396 regextst_openUTF8FromInvariant(&re, "abc", -1, &status); 2397 REGEX_VERBOSE_TEXT(&re); 2398 RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status); 2399 REGEX_CHECK_STATUS; 2400 2401 char data[] = { 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .abc..abc...abc.. */ 2402 // 012345678901234567 2403 UText dataText = UTEXT_INITIALIZER; 2404 utext_openUTF8(&dataText, data, -1, &status); 2405 REGEX_CHECK_STATUS; 2406 REGEX_VERBOSE_TEXT(&dataText); 2407 RegexMatcher *matcher = &pat->matcher(status)->reset(&dataText); 2408 2409 // 2410 // Plain vanilla matches. 2411 // 2412 UnicodeString dest; 2413 UText destText = UTEXT_INITIALIZER; 2414 utext_openUnicodeString(&destText, &dest, &status); 2415 UText *result; 2416 2417 UText replText = UTEXT_INITIALIZER; 2418 2419 const char str_yz[] = { 0x79, 0x7a, 0x00 }; /* yz */ 2420 utext_openUTF8(&replText, str_yz, -1, &status); 2421 REGEX_VERBOSE_TEXT(&replText); 2422 result = matcher->replaceFirst(&replText, NULL, status); 2423 REGEX_CHECK_STATUS; 2424 const char str_yzabcabc[] = { 0x2e, 0x79, 0x7a, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .yz..abc...abc.. */ 2425 REGEX_ASSERT_UTEXT_UTF8(str_yzabcabc, result); 2426 utext_close(result); 2427 result = matcher->replaceFirst(&replText, &destText, status); 2428 REGEX_CHECK_STATUS; 2429 REGEX_ASSERT(result == &destText); 2430 REGEX_ASSERT_UTEXT_UTF8(str_yzabcabc, result); 2431 2432 result = matcher->replaceAll(&replText, NULL, status); 2433 REGEX_CHECK_STATUS; 2434 const char str_yzyzyz[] = { 0x2e, 0x79, 0x7a, 0x2e, 0x2e, 0x79, 0x7a, 0x2e, 0x2e, 0x2e, 0x79, 0x7a, 0x2e, 0x2e, 0x00 }; /* .yz..yz...yz.. */ 2435 REGEX_ASSERT_UTEXT_UTF8(str_yzyzyz, result); 2436 utext_close(result); 2437 2438 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2439 result = matcher->replaceAll(&replText, &destText, status); 2440 REGEX_CHECK_STATUS; 2441 REGEX_ASSERT(result == &destText); 2442 REGEX_ASSERT_UTEXT_UTF8(str_yzyzyz, result); 2443 2444 // 2445 // Plain vanilla non-matches. 2446 // 2447 const char str_abxabxabx[] = { 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x00 }; /* .abx..abx...abx.. */ 2448 utext_openUTF8(&dataText, str_abxabxabx, -1, &status); 2449 matcher->reset(&dataText); 2450 2451 result = matcher->replaceFirst(&replText, NULL, status); 2452 REGEX_CHECK_STATUS; 2453 REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result); 2454 utext_close(result); 2455 result = matcher->replaceFirst(&replText, &destText, status); 2456 REGEX_CHECK_STATUS; 2457 REGEX_ASSERT(result == &destText); 2458 REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result); 2459 2460 result = matcher->replaceAll(&replText, NULL, status); 2461 REGEX_CHECK_STATUS; 2462 REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result); 2463 utext_close(result); 2464 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2465 result = matcher->replaceAll(&replText, &destText, status); 2466 REGEX_CHECK_STATUS; 2467 REGEX_ASSERT(result == &destText); 2468 REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result); 2469 2470 // 2471 // Empty source string 2472 // 2473 utext_openUTF8(&dataText, NULL, 0, &status); 2474 matcher->reset(&dataText); 2475 2476 result = matcher->replaceFirst(&replText, NULL, status); 2477 REGEX_CHECK_STATUS; 2478 REGEX_ASSERT_UTEXT_UTF8("", result); 2479 utext_close(result); 2480 result = matcher->replaceFirst(&replText, &destText, status); 2481 REGEX_CHECK_STATUS; 2482 REGEX_ASSERT(result == &destText); 2483 REGEX_ASSERT_UTEXT_UTF8("", result); 2484 2485 result = matcher->replaceAll(&replText, NULL, status); 2486 REGEX_CHECK_STATUS; 2487 REGEX_ASSERT_UTEXT_UTF8("", result); 2488 utext_close(result); 2489 result = matcher->replaceAll(&replText, &destText, status); 2490 REGEX_CHECK_STATUS; 2491 REGEX_ASSERT(result == &destText); 2492 REGEX_ASSERT_UTEXT_UTF8("", result); 2493 2494 // 2495 // Empty substitution string 2496 // 2497 utext_openUTF8(&dataText, data, -1, &status); // ".abc..abc...abc.." 2498 matcher->reset(&dataText); 2499 2500 utext_openUTF8(&replText, NULL, 0, &status); 2501 result = matcher->replaceFirst(&replText, NULL, status); 2502 REGEX_CHECK_STATUS; 2503 const char str_abcabc[] = { 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* ...abc...abc.. */ 2504 REGEX_ASSERT_UTEXT_UTF8(str_abcabc, result); 2505 utext_close(result); 2506 result = matcher->replaceFirst(&replText, &destText, status); 2507 REGEX_CHECK_STATUS; 2508 REGEX_ASSERT(result == &destText); 2509 REGEX_ASSERT_UTEXT_UTF8(str_abcabc, result); 2510 2511 result = matcher->replaceAll(&replText, NULL, status); 2512 REGEX_CHECK_STATUS; 2513 const char str_dots[] = { 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x00 }; /* ........ */ 2514 REGEX_ASSERT_UTEXT_UTF8(str_dots, result); 2515 utext_close(result); 2516 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2517 result = matcher->replaceAll(&replText, &destText, status); 2518 REGEX_CHECK_STATUS; 2519 REGEX_ASSERT(result == &destText); 2520 REGEX_ASSERT_UTEXT_UTF8(str_dots, result); 2521 2522 // 2523 // match whole string 2524 // 2525 const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */ 2526 utext_openUTF8(&dataText, str_abc, -1, &status); 2527 matcher->reset(&dataText); 2528 2529 const char str_xyz[] = { 0x78, 0x79, 0x7a, 0x00 }; /* xyz */ 2530 utext_openUTF8(&replText, str_xyz, -1, &status); 2531 result = matcher->replaceFirst(&replText, NULL, status); 2532 REGEX_CHECK_STATUS; 2533 REGEX_ASSERT_UTEXT_UTF8(str_xyz, result); 2534 utext_close(result); 2535 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2536 result = matcher->replaceFirst(&replText, &destText, status); 2537 REGEX_CHECK_STATUS; 2538 REGEX_ASSERT(result == &destText); 2539 REGEX_ASSERT_UTEXT_UTF8(str_xyz, result); 2540 2541 result = matcher->replaceAll(&replText, NULL, status); 2542 REGEX_CHECK_STATUS; 2543 REGEX_ASSERT_UTEXT_UTF8(str_xyz, result); 2544 utext_close(result); 2545 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2546 result = matcher->replaceAll(&replText, &destText, status); 2547 REGEX_CHECK_STATUS; 2548 REGEX_ASSERT(result == &destText); 2549 REGEX_ASSERT_UTEXT_UTF8(str_xyz, result); 2550 2551 // 2552 // Capture Group, simple case 2553 // 2554 const char str_add[] = { 0x61, 0x28, 0x2e, 0x2e, 0x29, 0x00 }; /* a(..) */ 2555 utext_openUTF8(&re, str_add, -1, &status); 2556 RegexPattern *pat2 = RegexPattern::compile(&re, flags, pe, status); 2557 REGEX_CHECK_STATUS; 2558 2559 const char str_abcdefg[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* abcdefg */ 2560 utext_openUTF8(&dataText, str_abcdefg, -1, &status); 2561 RegexMatcher *matcher2 = &pat2->matcher(status)->reset(&dataText); 2562 REGEX_CHECK_STATUS; 2563 2564 const char str_11[] = { 0x24, 0x31, 0x24, 0x31, 0x00 }; /* $1$1 */ 2565 utext_openUTF8(&replText, str_11, -1, &status); 2566 result = matcher2->replaceFirst(&replText, NULL, status); 2567 REGEX_CHECK_STATUS; 2568 const char str_bcbcdefg[] = { 0x62, 0x63, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* bcbcdefg */ 2569 REGEX_ASSERT_UTEXT_UTF8(str_bcbcdefg, result); 2570 utext_close(result); 2571 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2572 result = matcher2->replaceFirst(&replText, &destText, status); 2573 REGEX_CHECK_STATUS; 2574 REGEX_ASSERT(result == &destText); 2575 REGEX_ASSERT_UTEXT_UTF8(str_bcbcdefg, result); 2576 2577 const char str_v[24] = { 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x5c, 0x24, 0x31, 0x20, 0x69, 0x73, 0x20, 0x24, 0x31, 0x2e, 0x00 }; /* The value of \$1 is $1. */ 2578 utext_openUTF8(&replText, str_v, -1, &status); 2579 REGEX_VERBOSE_TEXT(&replText); 2580 result = matcher2->replaceFirst(&replText, NULL, status); 2581 REGEX_CHECK_STATUS; 2582 const char str_Thevalueof1isbcdefg[] = { 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x24, 0x31, 0x20, 0x69, 0x73, 0x20, 0x62, 0x63, 0x2e, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* The value of $1 is bc.defg */ 2583 REGEX_ASSERT_UTEXT_UTF8(str_Thevalueof1isbcdefg, result); 2584 utext_close(result); 2585 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2586 result = matcher2->replaceFirst(&replText, &destText, status); 2587 REGEX_CHECK_STATUS; 2588 REGEX_ASSERT(result == &destText); 2589 REGEX_ASSERT_UTEXT_UTF8(str_Thevalueof1isbcdefg, result); 2590 2591 const char str_byitselfnogroupnumber[] = { 0x24, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x24, 0x24, 0x00 }; /* $ by itself, no group number $$$ */ 2592 utext_openUTF8(&replText, str_byitselfnogroupnumber, -1, &status); 2593 result = matcher2->replaceFirst(&replText, NULL, status); 2594 REGEX_CHECK_STATUS; 2595 const char str_byitselfnogroupnumberdefg[] = { 0x24, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x24, 0x24, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* $ by itself, no group number $$$defg */ 2596 REGEX_ASSERT_UTEXT_UTF8(str_byitselfnogroupnumberdefg, result); 2597 utext_close(result); 2598 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2599 result = matcher2->replaceFirst(&replText, &destText, status); 2600 REGEX_CHECK_STATUS; 2601 REGEX_ASSERT(result == &destText); 2602 REGEX_ASSERT_UTEXT_UTF8(str_byitselfnogroupnumberdefg, result); 2603 2604 unsigned char supplDigitChars[] = { 0x53, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x20, 0x31, 0x20, 0x24, 0x78, 0x78, 0x78, 0x78, 0x2e, 0x00 }; /* Supplemental Digit 1 $xxxx. */ 2605 //unsigned char supplDigitChars[] = "Supplemental Digit 1 $xxxx."; // \U0001D7CF, MATHEMATICAL BOLD DIGIT ONE 2606 // 012345678901234567890123456 2607 supplDigitChars[22] = 0xF0; 2608 supplDigitChars[23] = 0x9D; 2609 supplDigitChars[24] = 0x9F; 2610 supplDigitChars[25] = 0x8F; 2611 utext_openUTF8(&replText, (char *)supplDigitChars, -1, &status); 2612 2613 result = matcher2->replaceFirst(&replText, NULL, status); 2614 REGEX_CHECK_STATUS; 2615 const char str_SupplementalDigit1bcdefg[] = { 0x53, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x20, 0x31, 0x20, 0x62, 0x63, 0x2e, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* Supplemental Digit 1 bc.defg */ 2616 REGEX_ASSERT_UTEXT_UTF8(str_SupplementalDigit1bcdefg, result); 2617 utext_close(result); 2618 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2619 result = matcher2->replaceFirst(&replText, &destText, status); 2620 REGEX_CHECK_STATUS; 2621 REGEX_ASSERT(result == &destText); 2622 REGEX_ASSERT_UTEXT_UTF8(str_SupplementalDigit1bcdefg, result); 2623 const char str_badcapturegroupnumber5[] = { 0x62, 0x61, 0x64, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x35, 0x2e, 0x2e, 0x2e, 0x00 }; /* bad capture group number $5..." */ 2624 utext_openUTF8(&replText, str_badcapturegroupnumber5, -1, &status); 2625 REGEX_ASSERT_FAIL((result = matcher2->replaceFirst(&replText, NULL, status)), U_INDEX_OUTOFBOUNDS_ERROR); 2626 // REGEX_ASSERT_UTEXT_UTF8("abcdefg", result); 2627 utext_close(result); 2628 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2629 REGEX_ASSERT_FAIL((result = matcher2->replaceFirst(&replText, &destText, status)), U_INDEX_OUTOFBOUNDS_ERROR); 2630 REGEX_ASSERT(result == &destText); 2631 // REGEX_ASSERT_UTEXT_UTF8("abcdefg", result); 2632 2633 // 2634 // Replacement String with \u hex escapes 2635 // 2636 { 2637 const char str_abc1abc2abc3[] = { 0x61, 0x62, 0x63, 0x20, 0x31, 0x20, 0x61, 0x62, 0x63, 0x20, 0x32, 0x20, 0x61, 0x62, 0x63, 0x20, 0x33, 0x00 }; /* abc 1 abc 2 abc 3 */ 2638 const char str_u0043[] = { 0x2d, 0x2d, 0x5c, 0x75, 0x30, 0x30, 0x34, 0x33, 0x2d, 0x2d, 0x00 }; /* --\u0043-- */ 2639 utext_openUTF8(&dataText, str_abc1abc2abc3, -1, &status); 2640 utext_openUTF8(&replText, str_u0043, -1, &status); 2641 matcher->reset(&dataText); 2642 2643 result = matcher->replaceAll(&replText, NULL, status); 2644 REGEX_CHECK_STATUS; 2645 const char str_C1C2C3[] = { 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x31, 0x20, 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x32, 0x20, 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x33, 0x00 }; /* --C-- 1 --C-- 2 --C-- 3 */ 2646 REGEX_ASSERT_UTEXT_UTF8(str_C1C2C3, result); 2647 utext_close(result); 2648 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2649 result = matcher->replaceAll(&replText, &destText, status); 2650 REGEX_CHECK_STATUS; 2651 REGEX_ASSERT(result == &destText); 2652 REGEX_ASSERT_UTEXT_UTF8(str_C1C2C3, result); 2653 } 2654 { 2655 const char str_abc[] = { 0x61, 0x62, 0x63, 0x20, 0x21, 0x00 }; /* abc ! */ 2656 utext_openUTF8(&dataText, str_abc, -1, &status); 2657 const char str_U00010000[] = { 0x2d, 0x2d, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2d, 0x2d, 0x00 }; /* --\U00010000-- */ 2658 utext_openUTF8(&replText, str_U00010000, -1, &status); 2659 matcher->reset(&dataText); 2660 2661 unsigned char expected[] = { 0x2d, 0x2d, 0x78, 0x78, 0x78, 0x78, 0x2d, 0x2d, 0x20, 0x21, 0x00 }; /* --xxxx-- ! */ // \U00010000, "LINEAR B SYLLABLE B008 A" 2662 // 0123456789 2663 expected[2] = 0xF0; 2664 expected[3] = 0x90; 2665 expected[4] = 0x80; 2666 expected[5] = 0x80; 2667 2668 result = matcher->replaceAll(&replText, NULL, status); 2669 REGEX_CHECK_STATUS; 2670 REGEX_ASSERT_UTEXT_UTF8((char *)expected, result); 2671 utext_close(result); 2672 utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status); 2673 result = matcher->replaceAll(&replText, &destText, status); 2674 REGEX_CHECK_STATUS; 2675 REGEX_ASSERT(result == &destText); 2676 REGEX_ASSERT_UTEXT_UTF8((char *)expected, result); 2677 } 2678 // TODO: need more through testing of capture substitutions. 2679 2680 // Bug 4057 2681 // 2682 { 2683 status = U_ZERO_ERROR; 2684 const char str_ssee[] = { 0x73, 0x73, 0x28, 0x2e, 0x2a, 0x3f, 0x29, 0x65, 0x65, 0x00 }; /* ss(.*?)ee */ 2685 const char str_blah[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x73, 0x73, 0x20, 0x73, 0x74, 0x75, 0x66, 0x66, 0x20, 0x65, 0x65, 0x20, 0x66, 0x69, 0x6e, 0x00 }; /* The matches start with ss and end with ee ss stuff ee fin */ 2686 const char str_ooh[] = { 0x6f, 0x6f, 0x68, 0x00 }; /* ooh */ 2687 utext_openUTF8(&re, str_ssee, -1, &status); 2688 utext_openUTF8(&dataText, str_blah, -1, &status); 2689 utext_openUTF8(&replText, str_ooh, -1, &status); 2690 2691 RegexMatcher m(&re, 0, status); 2692 REGEX_CHECK_STATUS; 2693 2694 UnicodeString result; 2695 UText resultText = UTEXT_INITIALIZER; 2696 utext_openUnicodeString(&resultText, &result, &status); 2697 2698 // Multiple finds do NOT bump up the previous appendReplacement postion. 2699 m.reset(&dataText); 2700 m.find(); 2701 m.find(); 2702 m.appendReplacement(&resultText, &replText, status); 2703 REGEX_CHECK_STATUS; 2704 const char str_blah2[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x00 }; /* The matches start with ss and end with ee ooh */ 2705 REGEX_ASSERT_UTEXT_UTF8(str_blah2, &resultText); 2706 2707 // After a reset into the interior of a string, appendReplacement still starts at beginning. 2708 status = U_ZERO_ERROR; 2709 result.truncate(0); 2710 utext_openUnicodeString(&resultText, &result, &status); 2711 m.reset(10, status); 2712 m.find(); 2713 m.find(); 2714 m.appendReplacement(&resultText, &replText, status); 2715 REGEX_CHECK_STATUS; 2716 const char str_blah3[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x00 }; /* The matches start with ss and end with ee ooh */ 2717 REGEX_ASSERT_UTEXT_UTF8(str_blah3, &resultText); 2718 2719 // find() at interior of string, appendReplacement still starts at beginning. 2720 status = U_ZERO_ERROR; 2721 result.truncate(0); 2722 utext_openUnicodeString(&resultText, &result, &status); 2723 m.reset(); 2724 m.find(10, status); 2725 m.find(); 2726 m.appendReplacement(&resultText, &replText, status); 2727 REGEX_CHECK_STATUS; 2728 const char str_blah8[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x00 }; /* The matches start with ss and end with ee ooh */ 2729 REGEX_ASSERT_UTEXT_UTF8(str_blah8, &resultText); 2730 2731 m.appendTail(&resultText, status); 2732 const char str_blah9[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x20, 0x66, 0x69, 0x6e, 0x00 }; /* The matches start with ss and end with ee ooh fin */ 2733 REGEX_ASSERT_UTEXT_UTF8(str_blah9, &resultText); 2734 2735 utext_close(&resultText); 2736 } 2737 2738 delete matcher2; 2739 delete pat2; 2740 delete matcher; 2741 delete pat; 2742 2743 utext_close(&dataText); 2744 utext_close(&replText); 2745 utext_close(&destText); 2746 utext_close(&re); 2747 } 2748 2749 2750 //--------------------------------------------------------------------------- 2751 // 2752 // API_Pattern_UTF8 Test that the API for class RegexPattern is 2753 // present and nominally working. 2754 // 2755 //--------------------------------------------------------------------------- 2756 void RegexTest::API_Pattern_UTF8() { 2757 RegexPattern pata; // Test default constructor to not crash. 2758 RegexPattern patb; 2759 2760 REGEX_ASSERT(pata == patb); 2761 REGEX_ASSERT(pata == pata); 2762 2763 UText re1 = UTEXT_INITIALIZER; 2764 UText re2 = UTEXT_INITIALIZER; 2765 UErrorCode status = U_ZERO_ERROR; 2766 UParseError pe; 2767 2768 const char str_abcalmz[] = { 0x61, 0x62, 0x63, 0x5b, 0x61, 0x2d, 0x6c, 0x5d, 0x5b, 0x6d, 0x2d, 0x7a, 0x5d, 0x00 }; /* abc[a-l][m-z] */ 2769 const char str_def[] = { 0x64, 0x65, 0x66, 0x00 }; /* def */ 2770 utext_openUTF8(&re1, str_abcalmz, -1, &status); 2771 utext_openUTF8(&re2, str_def, -1, &status); 2772 2773 RegexPattern *pat1 = RegexPattern::compile(&re1, 0, pe, status); 2774 RegexPattern *pat2 = RegexPattern::compile(&re2, 0, pe, status); 2775 REGEX_CHECK_STATUS; 2776 REGEX_ASSERT(*pat1 == *pat1); 2777 REGEX_ASSERT(*pat1 != pata); 2778 2779 // Assign 2780 patb = *pat1; 2781 REGEX_ASSERT(patb == *pat1); 2782 2783 // Copy Construct 2784 RegexPattern patc(*pat1); 2785 REGEX_ASSERT(patc == *pat1); 2786 REGEX_ASSERT(patb == patc); 2787 REGEX_ASSERT(pat1 != pat2); 2788 patb = *pat2; 2789 REGEX_ASSERT(patb != patc); 2790 REGEX_ASSERT(patb == *pat2); 2791 2792 // Compile with no flags. 2793 RegexPattern *pat1a = RegexPattern::compile(&re1, pe, status); 2794 REGEX_ASSERT(*pat1a == *pat1); 2795 2796 REGEX_ASSERT(pat1a->flags() == 0); 2797 2798 // Compile with different flags should be not equal 2799 RegexPattern *pat1b = RegexPattern::compile(&re1, UREGEX_CASE_INSENSITIVE, pe, status); 2800 REGEX_CHECK_STATUS; 2801 2802 REGEX_ASSERT(*pat1b != *pat1a); 2803 REGEX_ASSERT(pat1b->flags() == UREGEX_CASE_INSENSITIVE); 2804 REGEX_ASSERT(pat1a->flags() == 0); 2805 delete pat1b; 2806 2807 // clone 2808 RegexPattern *pat1c = pat1->clone(); 2809 REGEX_ASSERT(*pat1c == *pat1); 2810 REGEX_ASSERT(*pat1c != *pat2); 2811 2812 delete pat1c; 2813 delete pat1a; 2814 delete pat1; 2815 delete pat2; 2816 2817 utext_close(&re1); 2818 utext_close(&re2); 2819 2820 2821 // 2822 // Verify that a matcher created from a cloned pattern works. 2823 // (Jitterbug 3423) 2824 // 2825 { 2826 UErrorCode status = U_ZERO_ERROR; 2827 UText pattern = UTEXT_INITIALIZER; 2828 const char str_pL[] = { 0x5c, 0x70, 0x7b, 0x4c, 0x7d, 0x2b, 0x00 }; /* \p{L}+ */ 2829 utext_openUTF8(&pattern, str_pL, -1, &status); 2830 2831 RegexPattern *pSource = RegexPattern::compile(&pattern, 0, status); 2832 RegexPattern *pClone = pSource->clone(); 2833 delete pSource; 2834 RegexMatcher *mFromClone = pClone->matcher(status); 2835 REGEX_CHECK_STATUS; 2836 2837 UText input = UTEXT_INITIALIZER; 2838 const char str_HelloWorld[] = { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x00 }; /* Hello World */ 2839 utext_openUTF8(&input, str_HelloWorld, -1, &status); 2840 mFromClone->reset(&input); 2841 REGEX_ASSERT(mFromClone->find() == TRUE); 2842 REGEX_ASSERT(mFromClone->group(status) == "Hello"); 2843 REGEX_ASSERT(mFromClone->find() == TRUE); 2844 REGEX_ASSERT(mFromClone->group(status) == "World"); 2845 REGEX_ASSERT(mFromClone->find() == FALSE); 2846 delete mFromClone; 2847 delete pClone; 2848 2849 utext_close(&input); 2850 utext_close(&pattern); 2851 } 2852 2853 // 2854 // matches convenience API 2855 // 2856 { 2857 UErrorCode status = U_ZERO_ERROR; 2858 UText pattern = UTEXT_INITIALIZER; 2859 UText input = UTEXT_INITIALIZER; 2860 2861 const char str_randominput[] = { 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x00 }; /* random input */ 2862 utext_openUTF8(&input, str_randominput, -1, &status); 2863 2864 const char str_dotstar[] = { 0x2e, 0x2a, 0x00 }; /* .* */ 2865 utext_openUTF8(&pattern, str_dotstar, -1, &status); 2866 REGEX_ASSERT(RegexPattern::matches(&pattern, &input, pe, status) == TRUE); 2867 REGEX_CHECK_STATUS; 2868 2869 const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */ 2870 utext_openUTF8(&pattern, str_abc, -1, &status); 2871 REGEX_ASSERT(RegexPattern::matches("abc", "random input", pe, status) == FALSE); 2872 REGEX_CHECK_STATUS; 2873 2874 const char str_nput[] = { 0x2e, 0x2a, 0x6e, 0x70, 0x75, 0x74, 0x00 }; /* .*nput */ 2875 utext_openUTF8(&pattern, str_nput, -1, &status); 2876 REGEX_ASSERT(RegexPattern::matches(".*nput", "random input", pe, status) == TRUE); 2877 REGEX_CHECK_STATUS; 2878 2879 utext_openUTF8(&pattern, str_randominput, -1, &status); 2880 REGEX_ASSERT(RegexPattern::matches("random input", "random input", pe, status) == TRUE); 2881 REGEX_CHECK_STATUS; 2882 2883 const char str_u[] = { 0x2e, 0x2a, 0x75, 0x00 }; /* .*u */ 2884 utext_openUTF8(&pattern, str_u, -1, &status); 2885 REGEX_ASSERT(RegexPattern::matches(".*u", "random input", pe, status) == FALSE); 2886 REGEX_CHECK_STATUS; 2887 2888 utext_openUTF8(&input, str_abc, -1, &status); 2889 utext_openUTF8(&pattern, str_abc, -1, &status); 2890 status = U_INDEX_OUTOFBOUNDS_ERROR; 2891 REGEX_ASSERT(RegexPattern::matches("abc", "abc", pe, status) == FALSE); 2892 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 2893 2894 utext_close(&input); 2895 utext_close(&pattern); 2896 } 2897 2898 2899 // 2900 // Split() 2901 // 2902 status = U_ZERO_ERROR; 2903 const char str_spaceplus[] = { 0x20, 0x2b, 0x00 }; /* + */ 2904 utext_openUTF8(&re1, str_spaceplus, -1, &status); 2905 pat1 = RegexPattern::compile(&re1, pe, status); 2906 REGEX_CHECK_STATUS; 2907 UnicodeString fields[10]; 2908 2909 int32_t n; 2910 n = pat1->split("Now is the time", fields, 10, status); 2911 REGEX_CHECK_STATUS; 2912 REGEX_ASSERT(n==4); 2913 REGEX_ASSERT(fields[0]=="Now"); 2914 REGEX_ASSERT(fields[1]=="is"); 2915 REGEX_ASSERT(fields[2]=="the"); 2916 REGEX_ASSERT(fields[3]=="time"); 2917 REGEX_ASSERT(fields[4]==""); 2918 2919 n = pat1->split("Now is the time", fields, 2, status); 2920 REGEX_CHECK_STATUS; 2921 REGEX_ASSERT(n==2); 2922 REGEX_ASSERT(fields[0]=="Now"); 2923 REGEX_ASSERT(fields[1]=="is the time"); 2924 REGEX_ASSERT(fields[2]=="the"); // left over from previous test 2925 2926 fields[1] = "*"; 2927 status = U_ZERO_ERROR; 2928 n = pat1->split("Now is the time", fields, 1, status); 2929 REGEX_CHECK_STATUS; 2930 REGEX_ASSERT(n==1); 2931 REGEX_ASSERT(fields[0]=="Now is the time"); 2932 REGEX_ASSERT(fields[1]=="*"); 2933 status = U_ZERO_ERROR; 2934 2935 n = pat1->split(" Now is the time ", fields, 10, status); 2936 REGEX_CHECK_STATUS; 2937 REGEX_ASSERT(n==6); 2938 REGEX_ASSERT(fields[0]==""); 2939 REGEX_ASSERT(fields[1]=="Now"); 2940 REGEX_ASSERT(fields[2]=="is"); 2941 REGEX_ASSERT(fields[3]=="the"); 2942 REGEX_ASSERT(fields[4]=="time"); 2943 REGEX_ASSERT(fields[5]==""); 2944 REGEX_ASSERT(fields[6]==""); 2945 2946 fields[2] = "*"; 2947 n = pat1->split(" ", fields, 10, status); 2948 REGEX_CHECK_STATUS; 2949 REGEX_ASSERT(n==2); 2950 REGEX_ASSERT(fields[0]==""); 2951 REGEX_ASSERT(fields[1]==""); 2952 REGEX_ASSERT(fields[2]=="*"); 2953 2954 fields[0] = "foo"; 2955 n = pat1->split("", fields, 10, status); 2956 REGEX_CHECK_STATUS; 2957 REGEX_ASSERT(n==0); 2958 REGEX_ASSERT(fields[0]=="foo"); 2959 2960 delete pat1; 2961 2962 // split, with a pattern with (capture) 2963 regextst_openUTF8FromInvariant(&re1, "<(\\w*)>", -1, &status); 2964 pat1 = RegexPattern::compile(&re1, pe, status); 2965 REGEX_CHECK_STATUS; 2966 2967 status = U_ZERO_ERROR; 2968 fields[6] = fields[7] = "*"; 2969 n = pat1->split("<a>Now is <b>the time<c>", fields, 10, status); 2970 REGEX_CHECK_STATUS; 2971 REGEX_ASSERT(n==7); 2972 REGEX_ASSERT(fields[0]==""); 2973 REGEX_ASSERT(fields[1]=="a"); 2974 REGEX_ASSERT(fields[2]=="Now is "); 2975 REGEX_ASSERT(fields[3]=="b"); 2976 REGEX_ASSERT(fields[4]=="the time"); 2977 REGEX_ASSERT(fields[5]=="c"); 2978 REGEX_ASSERT(fields[6]==""); 2979 REGEX_ASSERT(fields[7]=="*"); 2980 REGEX_ASSERT(status==U_ZERO_ERROR); 2981 2982 fields[6] = fields[7] = "*"; 2983 n = pat1->split(" <a>Now is <b>the time<c>", fields, 10, status); 2984 REGEX_CHECK_STATUS; 2985 REGEX_ASSERT(n==7); 2986 REGEX_ASSERT(fields[0]==" "); 2987 REGEX_ASSERT(fields[1]=="a"); 2988 REGEX_ASSERT(fields[2]=="Now is "); 2989 REGEX_ASSERT(fields[3]=="b"); 2990 REGEX_ASSERT(fields[4]=="the time"); 2991 REGEX_ASSERT(fields[5]=="c"); 2992 REGEX_ASSERT(fields[6]==""); 2993 REGEX_ASSERT(fields[7]=="*"); 2994 2995 status = U_ZERO_ERROR; 2996 fields[6] = "foo"; 2997 n = pat1->split(" <a>Now is <b>the time<c> ", fields, 6, status); 2998 REGEX_CHECK_STATUS; 2999 REGEX_ASSERT(n==6); 3000 REGEX_ASSERT(fields[0]==" "); 3001 REGEX_ASSERT(fields[1]=="a"); 3002 REGEX_ASSERT(fields[2]=="Now is "); 3003 REGEX_ASSERT(fields[3]=="b"); 3004 REGEX_ASSERT(fields[4]=="the time"); 3005 REGEX_ASSERT(fields[5]==" "); 3006 REGEX_ASSERT(fields[6]=="foo"); 3007 3008 status = U_ZERO_ERROR; 3009 fields[5] = "foo"; 3010 n = pat1->split(" <a>Now is <b>the time<c>", fields, 5, status); 3011 REGEX_CHECK_STATUS; 3012 REGEX_ASSERT(n==5); 3013 REGEX_ASSERT(fields[0]==" "); 3014 REGEX_ASSERT(fields[1]=="a"); 3015 REGEX_ASSERT(fields[2]=="Now is "); 3016 REGEX_ASSERT(fields[3]=="b"); 3017 REGEX_ASSERT(fields[4]=="the time<c>"); 3018 REGEX_ASSERT(fields[5]=="foo"); 3019 3020 status = U_ZERO_ERROR; 3021 fields[5] = "foo"; 3022 n = pat1->split(" <a>Now is <b>the time", fields, 5, status); 3023 REGEX_CHECK_STATUS; 3024 REGEX_ASSERT(n==5); 3025 REGEX_ASSERT(fields[0]==" "); 3026 REGEX_ASSERT(fields[1]=="a"); 3027 REGEX_ASSERT(fields[2]=="Now is "); 3028 REGEX_ASSERT(fields[3]=="b"); 3029 REGEX_ASSERT(fields[4]=="the time"); 3030 REGEX_ASSERT(fields[5]=="foo"); 3031 3032 status = U_ZERO_ERROR; 3033 n = pat1->split(" <a>Now is <b>the time<c>", fields, 4, status); 3034 REGEX_CHECK_STATUS; 3035 REGEX_ASSERT(n==4); 3036 REGEX_ASSERT(fields[0]==" "); 3037 REGEX_ASSERT(fields[1]=="a"); 3038 REGEX_ASSERT(fields[2]=="Now is "); 3039 REGEX_ASSERT(fields[3]=="the time<c>"); 3040 status = U_ZERO_ERROR; 3041 delete pat1; 3042 3043 regextst_openUTF8FromInvariant(&re1, "([-,])", -1, &status); 3044 pat1 = RegexPattern::compile(&re1, pe, status); 3045 REGEX_CHECK_STATUS; 3046 n = pat1->split("1-10,20", fields, 10, status); 3047 REGEX_CHECK_STATUS; 3048 REGEX_ASSERT(n==5); 3049 REGEX_ASSERT(fields[0]=="1"); 3050 REGEX_ASSERT(fields[1]=="-"); 3051 REGEX_ASSERT(fields[2]=="10"); 3052 REGEX_ASSERT(fields[3]==","); 3053 REGEX_ASSERT(fields[4]=="20"); 3054 delete pat1; 3055 3056 3057 // 3058 // RegexPattern::pattern() and patternText() 3059 // 3060 pat1 = new RegexPattern(); 3061 REGEX_ASSERT(pat1->pattern() == ""); 3062 REGEX_ASSERT_UTEXT_UTF8("", pat1->patternText(status)); 3063 delete pat1; 3064 const char *helloWorldInvariant = "(Hello, world)*"; 3065 regextst_openUTF8FromInvariant(&re1, helloWorldInvariant, -1, &status); 3066 pat1 = RegexPattern::compile(&re1, pe, status); 3067 REGEX_CHECK_STATUS; 3068 REGEX_ASSERT_UNISTR(pat1->pattern(),"(Hello, world)*"); 3069 REGEX_ASSERT_UTEXT_INVARIANT("(Hello, world)*", pat1->patternText(status)); 3070 delete pat1; 3071 3072 utext_close(&re1); 3073 } 3074 3075 3076 //--------------------------------------------------------------------------- 3077 // 3078 // Extended A more thorough check for features of regex patterns 3079 // The test cases are in a separate data file, 3080 // source/tests/testdata/regextst.txt 3081 // A description of the test data format is included in that file. 3082 // 3083 //--------------------------------------------------------------------------- 3084 3085 const char * 3086 RegexTest::getPath(char buffer[2048], const char *filename) { 3087 UErrorCode status=U_ZERO_ERROR; 3088 const char *testDataDirectory = IntlTest::getSourceTestData(status); 3089 if (U_FAILURE(status)) { 3090 errln("ERROR: loadTestData() failed - %s", u_errorName(status)); 3091 return NULL; 3092 } 3093 3094 strcpy(buffer, testDataDirectory); 3095 strcat(buffer, filename); 3096 return buffer; 3097 } 3098 3099 void RegexTest::Extended() { 3100 char tdd[2048]; 3101 const char *srcPath; 3102 UErrorCode status = U_ZERO_ERROR; 3103 int32_t lineNum = 0; 3104 3105 // 3106 // Open and read the test data file. 3107 // 3108 srcPath=getPath(tdd, "regextst.txt"); 3109 if(srcPath==NULL) { 3110 return; /* something went wrong, error already output */ 3111 } 3112 3113 int32_t len; 3114 UChar *testData = ReadAndConvertFile(srcPath, len, "utf-8", status); 3115 if (U_FAILURE(status)) { 3116 return; /* something went wrong, error already output */ 3117 } 3118 3119 // 3120 // Put the test data into a UnicodeString 3121 // 3122 UnicodeString testString(FALSE, testData, len); 3123 3124 RegexMatcher quotedStuffMat(UNICODE_STRING_SIMPLE("\\s*([\\'\\\"/])(.*?)\\1"), 0, status); 3125 RegexMatcher commentMat (UNICODE_STRING_SIMPLE("\\s*(#.*)?$"), 0, status); 3126 RegexMatcher flagsMat (UNICODE_STRING_SIMPLE("\\s*([ixsmdteDEGLMQvabtyYzZ2-9]*)([:letter:]*)"), 0, status); 3127 3128 RegexMatcher lineMat(UNICODE_STRING_SIMPLE("(.*?)\\r?\\n"), testString, 0, status); 3129 UnicodeString testPattern; // The pattern for test from the test file. 3130 UnicodeString testFlags; // the flags for a test. 3131 UnicodeString matchString; // The marked up string to be used as input 3132 3133 if (U_FAILURE(status)){ 3134 dataerrln("Construct RegexMatcher() error - %s", u_errorName(status)); 3135 delete [] testData; 3136 return; 3137 } 3138 3139 // 3140 // Loop over the test data file, once per line. 3141 // 3142 while (lineMat.find()) { 3143 lineNum++; 3144 if (U_FAILURE(status)) { 3145 errln("%s:%d: ICU Error \"%s\"", srcPath, lineNum, u_errorName(status)); 3146 } 3147 3148 status = U_ZERO_ERROR; 3149 UnicodeString testLine = lineMat.group(1, status); 3150 if (testLine.length() == 0) { 3151 continue; 3152 } 3153 3154 // 3155 // Parse the test line. Skip blank and comment only lines. 3156 // Separate out the three main fields - pattern, flags, target. 3157 // 3158 3159 commentMat.reset(testLine); 3160 if (commentMat.lookingAt(status)) { 3161 // This line is a comment, or blank. 3162 continue; 3163 } 3164 3165 // 3166 // Pull out the pattern field, remove it from the test file line. 3167 // 3168 quotedStuffMat.reset(testLine); 3169 if (quotedStuffMat.lookingAt(status)) { 3170 testPattern = quotedStuffMat.group(2, status); 3171 testLine.remove(0, quotedStuffMat.end(0, status)); 3172 } else { 3173 errln("Bad pattern (missing quotes?) at %s:%d", srcPath, lineNum); 3174 continue; 3175 } 3176 3177 3178 // 3179 // Pull out the flags from the test file line. 3180 // 3181 flagsMat.reset(testLine); 3182 flagsMat.lookingAt(status); // Will always match, possibly an empty string. 3183 testFlags = flagsMat.group(1, status); 3184 if (flagsMat.group(2, status).length() > 0) { 3185 errln("Bad Match flag at line %d. Scanning %c\n", 3186 lineNum, flagsMat.group(2, status).charAt(0)); 3187 continue; 3188 } 3189 testLine.remove(0, flagsMat.end(0, status)); 3190 3191 // 3192 // Pull out the match string, as a whole. 3193 // We'll process the <tags> later. 3194 // 3195 quotedStuffMat.reset(testLine); 3196 if (quotedStuffMat.lookingAt(status)) { 3197 matchString = quotedStuffMat.group(2, status); 3198 testLine.remove(0, quotedStuffMat.end(0, status)); 3199 } else { 3200 errln("Bad match string at test file line %d", lineNum); 3201 continue; 3202 } 3203 3204 // 3205 // The only thing left from the input line should be an optional trailing comment. 3206 // 3207 commentMat.reset(testLine); 3208 if (commentMat.lookingAt(status) == FALSE) { 3209 errln("Line %d: unexpected characters at end of test line.", lineNum); 3210 continue; 3211 } 3212 3213 // 3214 // Run the test 3215 // 3216 regex_find(testPattern, testFlags, matchString, srcPath, lineNum); 3217 } 3218 3219 delete [] testData; 3220 3221 } 3222 3223 3224 3225 //--------------------------------------------------------------------------- 3226 // 3227 // regex_find(pattern, flags, inputString, lineNumber) 3228 // 3229 // Function to run a single test from the Extended (data driven) tests. 3230 // See file test/testdata/regextst.txt for a description of the 3231 // pattern and inputString fields, and the allowed flags. 3232 // lineNumber is the source line in regextst.txt of the test. 3233 // 3234 //--------------------------------------------------------------------------- 3235 3236 3237 // Set a value into a UVector at position specified by a decimal number in 3238 // a UnicodeString. This is a utility function needed by the actual test function, 3239 // which follows. 3240 static void set(UVector &vec, int32_t val, UnicodeString index) { 3241 UErrorCode status=U_ZERO_ERROR; 3242 int32_t idx = 0; 3243 for (int32_t i=0; i<index.length(); i++) { 3244 int32_t d=u_charDigitValue(index.charAt(i)); 3245 if (d<0) {return;} 3246 idx = idx*10 + d; 3247 } 3248 while (vec.size()<idx+1) {vec.addElement(-1, status);} 3249 vec.setElementAt(val, idx); 3250 } 3251 3252 static void setInt(UVector &vec, int32_t val, int32_t idx) { 3253 UErrorCode status=U_ZERO_ERROR; 3254 while (vec.size()<idx+1) {vec.addElement(-1, status);} 3255 vec.setElementAt(val, idx); 3256 } 3257 3258 static UBool utextOffsetToNative(UText *utext, int32_t unistrOffset, int32_t& nativeIndex) 3259 { 3260 UBool couldFind = TRUE; 3261 UTEXT_SETNATIVEINDEX(utext, 0); 3262 int32_t i = 0; 3263 while (i < unistrOffset) { 3264 UChar32 c = UTEXT_NEXT32(utext); 3265 if (c != U_SENTINEL) { 3266 i += U16_LENGTH(c); 3267 } else { 3268 couldFind = FALSE; 3269 break; 3270 } 3271 } 3272 nativeIndex = (int32_t)UTEXT_GETNATIVEINDEX(utext); 3273 return couldFind; 3274 } 3275 3276 3277 void RegexTest::regex_find(const UnicodeString &pattern, 3278 const UnicodeString &flags, 3279 const UnicodeString &inputString, 3280 const char *srcPath, 3281 int32_t line) { 3282 UnicodeString unEscapedInput; 3283 UnicodeString deTaggedInput; 3284 3285 int32_t patternUTF8Length, inputUTF8Length; 3286 char *patternChars = NULL, *inputChars = NULL; 3287 UText patternText = UTEXT_INITIALIZER; 3288 UText inputText = UTEXT_INITIALIZER; 3289 UConverter *UTF8Converter = NULL; 3290 3291 UErrorCode status = U_ZERO_ERROR; 3292 UParseError pe; 3293 RegexPattern *parsePat = NULL; 3294 RegexMatcher *parseMatcher = NULL; 3295 RegexPattern *callerPattern = NULL, *UTF8Pattern = NULL; 3296 RegexMatcher *matcher = NULL, *UTF8Matcher = NULL; 3297 UVector groupStarts(status); 3298 UVector groupEnds(status); 3299 UVector groupStartsUTF8(status); 3300 UVector groupEndsUTF8(status); 3301 UBool isMatch = FALSE, isUTF8Match = FALSE; 3302 UBool failed = FALSE; 3303 int32_t numFinds; 3304 int32_t i; 3305 UBool useMatchesFunc = FALSE; 3306 UBool useLookingAtFunc = FALSE; 3307 int32_t regionStart = -1; 3308 int32_t regionEnd = -1; 3309 int32_t regionStartUTF8 = -1; 3310 int32_t regionEndUTF8 = -1; 3311 3312 3313 // 3314 // Compile the caller's pattern 3315 // 3316 uint32_t bflags = 0; 3317 if (flags.indexOf((UChar)0x69) >= 0) { // 'i' flag 3318 bflags |= UREGEX_CASE_INSENSITIVE; 3319 } 3320 if (flags.indexOf((UChar)0x78) >= 0) { // 'x' flag 3321 bflags |= UREGEX_COMMENTS; 3322 } 3323 if (flags.indexOf((UChar)0x73) >= 0) { // 's' flag 3324 bflags |= UREGEX_DOTALL; 3325 } 3326 if (flags.indexOf((UChar)0x6d) >= 0) { // 'm' flag 3327 bflags |= UREGEX_MULTILINE; 3328 } 3329 3330 if (flags.indexOf((UChar)0x65) >= 0) { // 'e' flag 3331 bflags |= UREGEX_ERROR_ON_UNKNOWN_ESCAPES; 3332 } 3333 if (flags.indexOf((UChar)0x44) >= 0) { // 'D' flag 3334 bflags |= UREGEX_UNIX_LINES; 3335 } 3336 if (flags.indexOf((UChar)0x51) >= 0) { // 'Q' flag 3337 bflags |= UREGEX_LITERAL; 3338 } 3339 3340 3341 callerPattern = RegexPattern::compile(pattern, bflags, pe, status); 3342 if (status != U_ZERO_ERROR) { 3343 #if UCONFIG_NO_BREAK_ITERATION==1 3344 // 'v' test flag means that the test pattern should not compile if ICU was configured 3345 // to not include break iteration. RBBI is needed for Unicode word boundaries. 3346 if (flags.indexOf((UChar)0x76) >= 0 /*'v'*/ && status == U_UNSUPPORTED_ERROR) { 3347 goto cleanupAndReturn; 3348 } 3349 #endif 3350 if (flags.indexOf((UChar)0x45) >= 0) { // flags contain 'E' 3351 // Expected pattern compilation error. 3352 if (flags.indexOf((UChar)0x64) >= 0) { // flags contain 'd' 3353 logln("Pattern Compile returns \"%s\"", u_errorName(status)); 3354 } 3355 goto cleanupAndReturn; 3356 } else { 3357 // Unexpected pattern compilation error. 3358 dataerrln("Line %d: error %s compiling pattern.", line, u_errorName(status)); 3359 goto cleanupAndReturn; 3360 } 3361 } 3362 3363 UTF8Converter = ucnv_open("UTF8", &status); 3364 ucnv_setFromUCallBack(UTF8Converter, UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status); 3365 3366 patternUTF8Length = pattern.extract(NULL, 0, UTF8Converter, status); 3367 status = U_ZERO_ERROR; // buffer overflow 3368 patternChars = new char[patternUTF8Length+1]; 3369 pattern.extract(patternChars, patternUTF8Length+1, UTF8Converter, status); 3370 utext_openUTF8(&patternText, patternChars, patternUTF8Length, &status); 3371 3372 if (status == U_ZERO_ERROR) { 3373 UTF8Pattern = RegexPattern::compile(&patternText, bflags, pe, status); 3374 3375 if (status != U_ZERO_ERROR) { 3376 #if UCONFIG_NO_BREAK_ITERATION==1 3377 // 'v' test flag means that the test pattern should not compile if ICU was configured 3378 // to not include break iteration. RBBI is needed for Unicode word boundaries. 3379 if (flags.indexOf((UChar)0x76) >= 0 /*'v'*/ && status == U_UNSUPPORTED_ERROR) { 3380 goto cleanupAndReturn; 3381 } 3382 #endif 3383 if (flags.indexOf((UChar)0x45) >= 0) { // flags contain 'E' 3384 // Expected pattern compilation error. 3385 if (flags.indexOf((UChar)0x64) >= 0) { // flags contain 'd' 3386 logln("Pattern Compile returns \"%s\" (UTF8)", u_errorName(status)); 3387 } 3388 goto cleanupAndReturn; 3389 } else { 3390 // Unexpected pattern compilation error. 3391 errln("Line %d: error %s compiling pattern. (UTF8)", line, u_errorName(status)); 3392 goto cleanupAndReturn; 3393 } 3394 } 3395 } 3396 3397 if (UTF8Pattern == NULL) { 3398 // UTF-8 does not allow unpaired surrogates, so this could actually happen without being a failure of the engine 3399 logln("Unable to create UTF-8 pattern, skipping UTF-8 tests for %s:%d", srcPath, line); 3400 status = U_ZERO_ERROR; 3401 } 3402 3403 if (flags.indexOf((UChar)0x64) >= 0) { // 'd' flag 3404 RegexPatternDump(callerPattern); 3405 } 3406 3407 if (flags.indexOf((UChar)0x45) >= 0) { // 'E' flag 3408 errln("%s, Line %d: Expected, but did not get, a pattern compilation error.", srcPath, line); 3409 goto cleanupAndReturn; 3410 } 3411 3412 3413 // 3414 // Number of times find() should be called on the test string, default to 1 3415 // 3416 numFinds = 1; 3417 for (i=2; i<=9; i++) { 3418 if (flags.indexOf((UChar)(0x30 + i)) >= 0) { // digit flag 3419 if (numFinds != 1) { 3420 errln("Line %d: more than one digit flag. Scanning %d.", line, i); 3421 goto cleanupAndReturn; 3422 } 3423 numFinds = i; 3424 } 3425 } 3426 3427 // 'M' flag. Use matches() instead of find() 3428 if (flags.indexOf((UChar)0x4d) >= 0) { 3429 useMatchesFunc = TRUE; 3430 } 3431 if (flags.indexOf((UChar)0x4c) >= 0) { 3432 useLookingAtFunc = TRUE; 3433 } 3434 3435 // 3436 // Find the tags in the input data, remove them, and record the group boundary 3437 // positions. 3438 // 3439 parsePat = RegexPattern::compile("<(/?)(r|[0-9]+)>", 0, pe, status); 3440 REGEX_CHECK_STATUS_L(line); 3441 3442 unEscapedInput = inputString.unescape(); 3443 parseMatcher = parsePat->matcher(unEscapedInput, status); 3444 REGEX_CHECK_STATUS_L(line); 3445 while(parseMatcher->find()) { 3446 parseMatcher->appendReplacement(deTaggedInput, "", status); 3447 REGEX_CHECK_STATUS; 3448 UnicodeString groupNum = parseMatcher->group(2, status); 3449 if (groupNum == "r") { 3450 // <r> or </r>, a region specification within the string 3451 if (parseMatcher->group(1, status) == "/") { 3452 regionEnd = deTaggedInput.length(); 3453 } else { 3454 regionStart = deTaggedInput.length(); 3455 } 3456 } else { 3457 // <digits> or </digits>, a group match boundary tag. 3458 if (parseMatcher->group(1, status) == "/") { 3459 set(groupEnds, deTaggedInput.length(), groupNum); 3460 } else { 3461 set(groupStarts, deTaggedInput.length(), groupNum); 3462 } 3463 } 3464 } 3465 parseMatcher->appendTail(deTaggedInput); 3466 REGEX_ASSERT_L(groupStarts.size() == groupEnds.size(), line); 3467 if ((regionStart>=0 || regionEnd>=0) && (regionStart<0 || regionStart>regionEnd)) { 3468 errln("mismatched <r> tags"); 3469 failed = TRUE; 3470 goto cleanupAndReturn; 3471 } 3472 3473 // 3474 // Configure the matcher according to the flags specified with this test. 3475 // 3476 matcher = callerPattern->matcher(deTaggedInput, status); 3477 REGEX_CHECK_STATUS_L(line); 3478 if (flags.indexOf((UChar)0x74) >= 0) { // 't' trace flag 3479 matcher->setTrace(TRUE); 3480 } 3481 3482 if (UTF8Pattern != NULL) { 3483 inputUTF8Length = deTaggedInput.extract(NULL, 0, UTF8Converter, status); 3484 status = U_ZERO_ERROR; // buffer overflow 3485 inputChars = new char[inputUTF8Length+1]; 3486 deTaggedInput.extract(inputChars, inputUTF8Length+1, UTF8Converter, status); 3487 utext_openUTF8(&inputText, inputChars, inputUTF8Length, &status); 3488 3489 if (status == U_ZERO_ERROR) { 3490 UTF8Matcher = &UTF8Pattern->matcher(status)->reset(&inputText); 3491 REGEX_CHECK_STATUS_L(line); 3492 } 3493 3494 if (UTF8Matcher == NULL) { 3495 // UTF-8 does not allow unpaired surrogates, so this could actually happen without being a failure of the engine 3496 logln("Unable to create UTF-8 matcher, skipping UTF-8 tests for %s:%d", srcPath, line); 3497 status = U_ZERO_ERROR; 3498 } 3499 } 3500 3501 // 3502 // Generate native indices for UTF8 versions of region and capture group info 3503 // 3504 if (UTF8Matcher != NULL) { 3505 if (regionStart>=0) (void) utextOffsetToNative(&inputText, regionStart, regionStartUTF8); 3506 if (regionEnd>=0) (void) utextOffsetToNative(&inputText, regionEnd, regionEndUTF8); 3507 3508 // Fill out the native index UVector info. 3509 // Only need 1 loop, from above we know groupStarts.size() = groupEnds.size() 3510 for (i=0; i<groupStarts.size(); i++) { 3511 int32_t start = groupStarts.elementAti(i); 3512 // -1 means there was no UVector slot and we won't be requesting that capture group for this test, don't bother inserting 3513 if (start >= 0) { 3514 int32_t startUTF8; 3515 if (!utextOffsetToNative(&inputText, start, startUTF8)) { 3516 errln("Error at line %d: could not find native index for group start %d. UTF16 index %d", line, i, start); 3517 failed = TRUE; 3518 goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now. 3519 } 3520 setInt(groupStartsUTF8, startUTF8, i); 3521 } 3522 3523 int32_t end = groupEnds.elementAti(i); 3524 // -1 means there was no UVector slot and we won't be requesting that capture group for this test, don't bother inserting 3525 if (end >= 0) { 3526 int32_t endUTF8; 3527 if (!utextOffsetToNative(&inputText, end, endUTF8)) { 3528 errln("Error at line %d: could not find native index for group end %d. UTF16 index %d", line, i, end); 3529 failed = TRUE; 3530 goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now. 3531 } 3532 setInt(groupEndsUTF8, endUTF8, i); 3533 } 3534 } 3535 } 3536 3537 if (regionStart>=0) { 3538 matcher->region(regionStart, regionEnd, status); 3539 REGEX_CHECK_STATUS_L(line); 3540 if (UTF8Matcher != NULL) { 3541 UTF8Matcher->region(regionStartUTF8, regionEndUTF8, status); 3542 REGEX_CHECK_STATUS_L(line); 3543 } 3544 } 3545 if (flags.indexOf((UChar)0x61) >= 0) { // 'a' anchoring bounds flag 3546 matcher->useAnchoringBounds(FALSE); 3547 if (UTF8Matcher != NULL) { 3548 UTF8Matcher->useAnchoringBounds(FALSE); 3549 } 3550 } 3551 if (flags.indexOf((UChar)0x62) >= 0) { // 'b' transparent bounds flag 3552 matcher->useTransparentBounds(TRUE); 3553 if (UTF8Matcher != NULL) { 3554 UTF8Matcher->useTransparentBounds(TRUE); 3555 } 3556 } 3557 3558 3559 3560 // 3561 // Do a find on the de-tagged input using the caller's pattern 3562 // TODO: error on count>1 and not find(). 3563 // error on both matches() and lookingAt(). 3564 // 3565 for (i=0; i<numFinds; i++) { 3566 if (useMatchesFunc) { 3567 isMatch = matcher->matches(status); 3568 if (UTF8Matcher != NULL) { 3569 isUTF8Match = UTF8Matcher->matches(status); 3570 } 3571 } else if (useLookingAtFunc) { 3572 isMatch = matcher->lookingAt(status); 3573 if (UTF8Matcher != NULL) { 3574 isUTF8Match = UTF8Matcher->lookingAt(status); 3575 } 3576 } else { 3577 isMatch = matcher->find(); 3578 if (UTF8Matcher != NULL) { 3579 isUTF8Match = UTF8Matcher->find(); 3580 } 3581 } 3582 } 3583 matcher->setTrace(FALSE); 3584 if (U_FAILURE(status)) { 3585 errln("Error at line %d. ICU ErrorCode is %s", u_errorName(status)); 3586 } 3587 3588 // 3589 // Match up the groups from the find() with the groups from the tags 3590 // 3591 3592 // number of tags should match number of groups from find operation. 3593 // matcher->groupCount does not include group 0, the entire match, hence the +1. 3594 // G option in test means that capture group data is not available in the 3595 // expected results, so the check needs to be suppressed. 3596 if (isMatch == FALSE && groupStarts.size() != 0) { 3597 dataerrln("Error at line %d: Match expected, but none found.", line); 3598 failed = TRUE; 3599 goto cleanupAndReturn; 3600 } else if (UTF8Matcher != NULL && isUTF8Match == FALSE && groupStarts.size() != 0) { 3601 errln("Error at line %d: Match expected, but none found. (UTF8)", line); 3602 failed = TRUE; 3603 goto cleanupAndReturn; 3604 } 3605 3606 if (flags.indexOf((UChar)0x47 /*G*/) >= 0) { 3607 // Only check for match / no match. Don't check capture groups. 3608 if (isMatch && groupStarts.size() == 0) { 3609 errln("Error at line %d: No match expected, but one found.", line); 3610 failed = TRUE; 3611 } else if (UTF8Matcher != NULL && isUTF8Match && groupStarts.size() == 0) { 3612 errln("Error at line %d: No match expected, but one found. (UTF8)", line); 3613 failed = TRUE; 3614 } 3615 goto cleanupAndReturn; 3616 } 3617 3618 REGEX_CHECK_STATUS_L(line); 3619 for (i=0; i<=matcher->groupCount(); i++) { 3620 int32_t expectedStart = (i >= groupStarts.size()? -1 : groupStarts.elementAti(i)); 3621 int32_t expectedStartUTF8 = (i >= groupStartsUTF8.size()? -1 : groupStartsUTF8.elementAti(i)); 3622 if (matcher->start(i, status) != expectedStart) { 3623 errln("Error at line %d: incorrect start position for group %d. Expected %d, got %d", 3624 line, i, expectedStart, matcher->start(i, status)); 3625 failed = TRUE; 3626 goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now. 3627 } else if (UTF8Matcher != NULL && UTF8Matcher->start(i, status) != expectedStartUTF8) { 3628 errln("Error at line %d: incorrect start position for group %d. Expected %d, got %d (UTF8)", 3629 line, i, expectedStartUTF8, UTF8Matcher->start(i, status)); 3630 failed = TRUE; 3631 goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now. 3632 } 3633 3634 int32_t expectedEnd = (i >= groupEnds.size()? -1 : groupEnds.elementAti(i)); 3635 int32_t expectedEndUTF8 = (i >= groupEndsUTF8.size()? -1 : groupEndsUTF8.elementAti(i)); 3636 if (matcher->end(i, status) != expectedEnd) { 3637 errln("Error at line %d: incorrect end position for group %d. Expected %d, got %d", 3638 line, i, expectedEnd, matcher->end(i, status)); 3639 failed = TRUE; 3640 // Error on end position; keep going; real error is probably yet to come as group 3641 // end positions work from end of the input data towards the front. 3642 } else if (UTF8Matcher != NULL && UTF8Matcher->end(i, status) != expectedEndUTF8) { 3643 errln("Error at line %d: incorrect end position for group %d. Expected %d, got %d (UTF8)", 3644 line, i, expectedEndUTF8, UTF8Matcher->end(i, status)); 3645 failed = TRUE; 3646 // Error on end position; keep going; real error is probably yet to come as group 3647 // end positions work from end of the input data towards the front. 3648 } 3649 } 3650 if ( matcher->groupCount()+1 < groupStarts.size()) { 3651 errln("Error at line %d: Expected %d capture groups, found %d.", 3652 line, groupStarts.size()-1, matcher->groupCount()); 3653 failed = TRUE; 3654 } 3655 else if (UTF8Matcher != NULL && UTF8Matcher->groupCount()+1 < groupStarts.size()) { 3656 errln("Error at line %d: Expected %d capture groups, found %d. (UTF8)", 3657 line, groupStarts.size()-1, UTF8Matcher->groupCount()); 3658 failed = TRUE; 3659 } 3660 3661 if ((flags.indexOf((UChar)0x59) >= 0) && // 'Y' flag: RequireEnd() == false 3662 matcher->requireEnd() == TRUE) { 3663 errln("Error at line %d: requireEnd() returned TRUE. Expected FALSE", line); 3664 failed = TRUE; 3665 } else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x59) >= 0) && // 'Y' flag: RequireEnd() == false 3666 UTF8Matcher->requireEnd() == TRUE) { 3667 errln("Error at line %d: requireEnd() returned TRUE. Expected FALSE (UTF8)", line); 3668 failed = TRUE; 3669 } 3670 3671 if ((flags.indexOf((UChar)0x79) >= 0) && // 'y' flag: RequireEnd() == true 3672 matcher->requireEnd() == FALSE) { 3673 errln("Error at line %d: requireEnd() returned FALSE. Expected TRUE", line); 3674 failed = TRUE; 3675 } else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x79) >= 0) && // 'Y' flag: RequireEnd() == false 3676 UTF8Matcher->requireEnd() == FALSE) { 3677 errln("Error at line %d: requireEnd() returned FALSE. Expected TRUE (UTF8)", line); 3678 failed = TRUE; 3679 } 3680 3681 if ((flags.indexOf((UChar)0x5A) >= 0) && // 'Z' flag: hitEnd() == false 3682 matcher->hitEnd() == TRUE) { 3683 errln("Error at line %d: hitEnd() returned TRUE. Expected FALSE", line); 3684 failed = TRUE; 3685 } else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x5A) >= 0) && // 'Z' flag: hitEnd() == false 3686 UTF8Matcher->hitEnd() == TRUE) { 3687 errln("Error at line %d: hitEnd() returned TRUE. Expected FALSE (UTF8)", line); 3688 failed = TRUE; 3689 } 3690 3691 if ((flags.indexOf((UChar)0x7A) >= 0) && // 'z' flag: hitEnd() == true 3692 matcher->hitEnd() == FALSE) { 3693 errln("Error at line %d: hitEnd() returned FALSE. Expected TRUE", line); 3694 failed = TRUE; 3695 } else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x7A) >= 0) && // 'z' flag: hitEnd() == true 3696 UTF8Matcher->hitEnd() == FALSE) { 3697 errln("Error at line %d: hitEnd() returned FALSE. Expected TRUE (UTF8)", line); 3698 failed = TRUE; 3699 } 3700 3701 3702 cleanupAndReturn: 3703 if (failed) { 3704 infoln((UnicodeString)"\""+pattern+(UnicodeString)"\" " 3705 +flags+(UnicodeString)" \""+inputString+(UnicodeString)"\""); 3706 // callerPattern->dump(); 3707 } 3708 delete parseMatcher; 3709 delete parsePat; 3710 delete UTF8Matcher; 3711 delete UTF8Pattern; 3712 delete matcher; 3713 delete callerPattern; 3714 3715 utext_close(&inputText); 3716 delete[] inputChars; 3717 utext_close(&patternText); 3718 delete[] patternChars; 3719 ucnv_close(UTF8Converter); 3720 } 3721 3722 3723 3724 3725 //--------------------------------------------------------------------------- 3726 // 3727 // Errors Check for error handling in patterns. 3728 // 3729 //--------------------------------------------------------------------------- 3730 void RegexTest::Errors() { 3731 // \escape sequences that aren't implemented yet. 3732 //REGEX_ERR("hex format \\x{abcd} not implemented", 1, 13, U_REGEX_UNIMPLEMENTED); 3733 3734 // Missing close parentheses 3735 REGEX_ERR("Comment (?# with no close", 1, 25, U_REGEX_MISMATCHED_PAREN); 3736 REGEX_ERR("Capturing Parenthesis(...", 1, 25, U_REGEX_MISMATCHED_PAREN); 3737 REGEX_ERR("Grouping only parens (?: blah blah", 1, 34, U_REGEX_MISMATCHED_PAREN); 3738 3739 // Extra close paren 3740 REGEX_ERR("Grouping only parens (?: blah)) blah", 1, 31, U_REGEX_MISMATCHED_PAREN); 3741 REGEX_ERR(")))))))", 1, 1, U_REGEX_MISMATCHED_PAREN); 3742 REGEX_ERR("(((((((", 1, 7, U_REGEX_MISMATCHED_PAREN); 3743 3744 // Look-ahead, Look-behind 3745 // TODO: add tests for unbounded length look-behinds. 3746 REGEX_ERR("abc(?<@xyz).*", 1, 7, U_REGEX_RULE_SYNTAX); // illegal construct 3747 3748 // Attempt to use non-default flags 3749 { 3750 UParseError pe; 3751 UErrorCode status = U_ZERO_ERROR; 3752 int32_t flags = UREGEX_CANON_EQ | 3753 UREGEX_COMMENTS | UREGEX_DOTALL | 3754 UREGEX_MULTILINE; 3755 RegexPattern *pat1= RegexPattern::compile(".*", flags, pe, status); 3756 REGEX_ASSERT(status == U_REGEX_UNIMPLEMENTED); 3757 delete pat1; 3758 } 3759 3760 3761 // Quantifiers are allowed only after something that can be quantified. 3762 REGEX_ERR("+", 1, 1, U_REGEX_RULE_SYNTAX); 3763 REGEX_ERR("abc\ndef(*2)", 2, 5, U_REGEX_RULE_SYNTAX); 3764 REGEX_ERR("abc**", 1, 5, U_REGEX_RULE_SYNTAX); 3765 3766 // Mal-formed {min,max} quantifiers 3767 REGEX_ERR("abc{a,2}",1,5, U_REGEX_BAD_INTERVAL); 3768 REGEX_ERR("abc{4,2}",1,8, U_REGEX_MAX_LT_MIN); 3769 REGEX_ERR("abc{1,b}",1,7, U_REGEX_BAD_INTERVAL); 3770 REGEX_ERR("abc{1,,2}",1,7, U_REGEX_BAD_INTERVAL); 3771 REGEX_ERR("abc{1,2a}",1,8, U_REGEX_BAD_INTERVAL); 3772 REGEX_ERR("abc{222222222222222222222}",1,14, U_REGEX_NUMBER_TOO_BIG); 3773 REGEX_ERR("abc{5,50000000000}", 1, 17, U_REGEX_NUMBER_TOO_BIG); // Overflows int during scan 3774 REGEX_ERR("abc{5,687865858}", 1, 16, U_REGEX_NUMBER_TOO_BIG); // Overflows regex binary format 3775 REGEX_ERR("abc{687865858,687865859}", 1, 24, U_REGEX_NUMBER_TOO_BIG); 3776 3777 // Ticket 5389 3778 REGEX_ERR("*c", 1, 1, U_REGEX_RULE_SYNTAX); 3779 3780 // Invalid Back Reference \0 3781 // For ICU 3.8 and earlier 3782 // For ICU versions newer than 3.8, \0 introduces an octal escape. 3783 // 3784 REGEX_ERR("(ab)\\0", 1, 6, U_REGEX_BAD_ESCAPE_SEQUENCE); 3785 3786 } 3787 3788 3789 //------------------------------------------------------------------------------- 3790 // 3791 // Read a text data file, convert it to UChars, and return the data 3792 // in one big UChar * buffer, which the caller must delete. 3793 // 3794 //-------------------------------------------------------------------------------- 3795 UChar *RegexTest::ReadAndConvertFile(const char *fileName, int32_t &ulen, 3796 const char *defEncoding, UErrorCode &status) { 3797 UChar *retPtr = NULL; 3798 char *fileBuf = NULL; 3799 UConverter* conv = NULL; 3800 FILE *f = NULL; 3801 3802 ulen = 0; 3803 if (U_FAILURE(status)) { 3804 return retPtr; 3805 } 3806 3807 // 3808 // Open the file. 3809 // 3810 f = fopen(fileName, "rb"); 3811 if (f == 0) { 3812 dataerrln("Error opening test data file %s\n", fileName); 3813 status = U_FILE_ACCESS_ERROR; 3814 return NULL; 3815 } 3816 // 3817 // Read it in 3818 // 3819 int32_t fileSize; 3820 int32_t amt_read; 3821 3822 fseek( f, 0, SEEK_END); 3823 fileSize = ftell(f); 3824 fileBuf = new char[fileSize]; 3825 fseek(f, 0, SEEK_SET); 3826 amt_read = fread(fileBuf, 1, fileSize, f); 3827 if (amt_read != fileSize || fileSize <= 0) { 3828 errln("Error reading test data file."); 3829 goto cleanUpAndReturn; 3830 } 3831 3832 // 3833 // Look for a Unicode Signature (BOM) on the data just read 3834 // 3835 int32_t signatureLength; 3836 const char * fileBufC; 3837 const char* encoding; 3838 3839 fileBufC = fileBuf; 3840 encoding = ucnv_detectUnicodeSignature( 3841 fileBuf, fileSize, &signatureLength, &status); 3842 if(encoding!=NULL ){ 3843 fileBufC += signatureLength; 3844 fileSize -= signatureLength; 3845 } else { 3846 encoding = defEncoding; 3847 if (strcmp(encoding, "utf-8") == 0) { 3848 errln("file %s is missing its BOM", fileName); 3849 } 3850 } 3851 3852 // 3853 // Open a converter to take the rule file to UTF-16 3854 // 3855 conv = ucnv_open(encoding, &status); 3856 if (U_FAILURE(status)) { 3857 goto cleanUpAndReturn; 3858 } 3859 3860 // 3861 // Convert the rules to UChar. 3862 // Preflight first to determine required buffer size. 3863 // 3864 ulen = ucnv_toUChars(conv, 3865 NULL, // dest, 3866 0, // destCapacity, 3867 fileBufC, 3868 fileSize, 3869 &status); 3870 if (status == U_BUFFER_OVERFLOW_ERROR) { 3871 // Buffer Overflow is expected from the preflight operation. 3872 status = U_ZERO_ERROR; 3873 3874 retPtr = new UChar[ulen+1]; 3875 ucnv_toUChars(conv, 3876 retPtr, // dest, 3877 ulen+1, 3878 fileBufC, 3879 fileSize, 3880 &status); 3881 } 3882 3883 cleanUpAndReturn: 3884 fclose(f); 3885 delete[] fileBuf; 3886 ucnv_close(conv); 3887 if (U_FAILURE(status)) { 3888 errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status)); 3889 delete []retPtr; 3890 retPtr = 0; 3891 ulen = 0; 3892 }; 3893 return retPtr; 3894 } 3895 3896 3897 //------------------------------------------------------------------------------- 3898 // 3899 // PerlTests - Run Perl's regular expression tests 3900 // The input file for this test is re_tests, the standard regular 3901 // expression test data distributed with the Perl source code. 3902 // 3903 // Here is Perl's description of the test data file: 3904 // 3905 // # The tests are in a separate file 't/op/re_tests'. 3906 // # Each line in that file is a separate test. 3907 // # There are five columns, separated by tabs. 3908 // # 3909 // # Column 1 contains the pattern, optionally enclosed in C<''>. 3910 // # Modifiers can be put after the closing C<'>. 3911 // # 3912 // # Column 2 contains the string to be matched. 3913 // # 3914 // # Column 3 contains the expected result: 3915 // # y expect a match 3916 // # n expect no match 3917 // # c expect an error 3918 // # B test exposes a known bug in Perl, should be skipped 3919 // # b test exposes a known bug in Perl, should be skipped if noamp 3920 // # 3921 // # Columns 4 and 5 are used only if column 3 contains C<y> or C<c>. 3922 // # 3923 // # Column 4 contains a string, usually C<$&>. 3924 // # 3925 // # Column 5 contains the expected result of double-quote 3926 // # interpolating that string after the match, or start of error message. 3927 // # 3928 // # Column 6, if present, contains a reason why the test is skipped. 3929 // # This is printed with "skipped", for harness to pick up. 3930 // # 3931 // # \n in the tests are interpolated, as are variables of the form ${\w+}. 3932 // # 3933 // # If you want to add a regular expression test that can't be expressed 3934 // # in this format, don't add it here: put it in op/pat.t instead. 3935 // 3936 // For ICU, if field 3 contains an 'i', the test will be skipped. 3937 // The test exposes is some known incompatibility between ICU and Perl regexps. 3938 // (The i is in addition to whatever was there before.) 3939 // 3940 //------------------------------------------------------------------------------- 3941 void RegexTest::PerlTests() { 3942 char tdd[2048]; 3943 const char *srcPath; 3944 UErrorCode status = U_ZERO_ERROR; 3945 UParseError pe; 3946 3947 // 3948 // Open and read the test data file. 3949 // 3950 srcPath=getPath(tdd, "re_tests.txt"); 3951 if(srcPath==NULL) { 3952 return; /* something went wrong, error already output */ 3953 } 3954 3955 int32_t len; 3956 UChar *testData = ReadAndConvertFile(srcPath, len, "iso-8859-1", status); 3957 if (U_FAILURE(status)) { 3958 return; /* something went wrong, error already output */ 3959 } 3960 3961 // 3962 // Put the test data into a UnicodeString 3963 // 3964 UnicodeString testDataString(FALSE, testData, len); 3965 3966 // 3967 // Regex to break the input file into lines, and strip the new lines. 3968 // One line per match, capture group one is the desired data. 3969 // 3970 RegexPattern* linePat = RegexPattern::compile(UNICODE_STRING_SIMPLE("(.+?)[\\r\\n]+"), 0, pe, status); 3971 if (U_FAILURE(status)) { 3972 dataerrln("RegexPattern::compile() error"); 3973 return; 3974 } 3975 RegexMatcher* lineMat = linePat->matcher(testDataString, status); 3976 3977 // 3978 // Regex to split a test file line into fields. 3979 // There are six fields, separated by tabs. 3980 // 3981 RegexPattern* fieldPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\t"), 0, pe, status); 3982 3983 // 3984 // Regex to identify test patterns with flag settings, and to separate them. 3985 // Test patterns with flags look like 'pattern'i 3986 // Test patterns without flags are not quoted: pattern 3987 // Coming out, capture group 2 is the pattern, capture group 3 is the flags. 3988 // 3989 RegexPattern *flagPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("('?)(.*)\\1(.*)"), 0, pe, status); 3990 RegexMatcher* flagMat = flagPat->matcher(status); 3991 3992 // 3993 // The Perl tests reference several perl-isms, which are evaluated/substituted 3994 // in the test data. Not being perl, this must be done explicitly. Here 3995 // are string constants and REs for these constructs. 3996 // 3997 UnicodeString nulnulSrc("${nulnul}"); 3998 UnicodeString nulnul("\\u0000\\u0000", -1, US_INV); 3999 nulnul = nulnul.unescape(); 4000 4001 UnicodeString ffffSrc("${ffff}"); 4002 UnicodeString ffff("\\uffff", -1, US_INV); 4003 ffff = ffff.unescape(); 4004 4005 // regexp for $-[0], $+[2], etc. 4006 RegexPattern *groupsPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$([+\\-])\\[(\\d+)\\]"), 0, pe, status); 4007 RegexMatcher *groupsMat = groupsPat->matcher(status); 4008 4009 // regexp for $0, $1, $2, etc. 4010 RegexPattern *cgPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$(\\d+)"), 0, pe, status); 4011 RegexMatcher *cgMat = cgPat->matcher(status); 4012 4013 4014 // 4015 // Main Loop for the Perl Tests, runs once per line from the 4016 // test data file. 4017 // 4018 int32_t lineNum = 0; 4019 int32_t skippedUnimplementedCount = 0; 4020 while (lineMat->find()) { 4021 lineNum++; 4022 4023 // 4024 // Get a line, break it into its fields, do the Perl 4025 // variable substitutions. 4026 // 4027 UnicodeString line = lineMat->group(1, status); 4028 UnicodeString fields[7]; 4029 fieldPat->split(line, fields, 7, status); 4030 4031 flagMat->reset(fields[0]); 4032 flagMat->matches(status); 4033 UnicodeString pattern = flagMat->group(2, status); 4034 pattern.findAndReplace("${bang}", "!"); 4035 pattern.findAndReplace(nulnulSrc, UNICODE_STRING_SIMPLE("\\u0000\\u0000")); 4036 pattern.findAndReplace(ffffSrc, ffff); 4037 4038 // 4039 // Identify patterns that include match flag settings, 4040 // split off the flags, remove the extra quotes. 4041 // 4042 UnicodeString flagStr = flagMat->group(3, status); 4043 if (U_FAILURE(status)) { 4044 errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status)); 4045 return; 4046 } 4047 int32_t flags = 0; 4048 const UChar UChar_c = 0x63; // Char constants for the flag letters. 4049 const UChar UChar_i = 0x69; // (Damn the lack of Unicode support in C) 4050 const UChar UChar_m = 0x6d; 4051 const UChar UChar_x = 0x78; 4052 const UChar UChar_y = 0x79; 4053 if (flagStr.indexOf(UChar_i) != -1) { 4054 flags |= UREGEX_CASE_INSENSITIVE; 4055 } 4056 if (flagStr.indexOf(UChar_m) != -1) { 4057 flags |= UREGEX_MULTILINE; 4058 } 4059 if (flagStr.indexOf(UChar_x) != -1) { 4060 flags |= UREGEX_COMMENTS; 4061 } 4062 4063 // 4064 // Compile the test pattern. 4065 // 4066 status = U_ZERO_ERROR; 4067 RegexPattern *testPat = RegexPattern::compile(pattern, flags, pe, status); 4068 if (status == U_REGEX_UNIMPLEMENTED) { 4069 // 4070 // Test of a feature that is planned for ICU, but not yet implemented. 4071 // skip the test. 4072 skippedUnimplementedCount++; 4073 delete testPat; 4074 status = U_ZERO_ERROR; 4075 continue; 4076 } 4077 4078 if (U_FAILURE(status)) { 4079 // Some tests are supposed to generate errors. 4080 // Only report an error for tests that are supposed to succeed. 4081 if (fields[2].indexOf(UChar_c) == -1 && // Compilation is not supposed to fail AND 4082 fields[2].indexOf(UChar_i) == -1) // it's not an accepted ICU incompatibility 4083 { 4084 errln("line %d: ICU Error \"%s\"\n", lineNum, u_errorName(status)); 4085 } 4086 status = U_ZERO_ERROR; 4087 delete testPat; 4088 continue; 4089 } 4090 4091 if (fields[2].indexOf(UChar_i) >= 0) { 4092 // ICU should skip this test. 4093 delete testPat; 4094 continue; 4095 } 4096 4097 if (fields[2].indexOf(UChar_c) >= 0) { 4098 // This pattern should have caused a compilation error, but didn't/ 4099 errln("line %d: Expected a pattern compile error, got success.", lineNum); 4100 delete testPat; 4101 continue; 4102 } 4103 4104 // 4105 // replace the Perl variables that appear in some of the 4106 // match data strings. 4107 // 4108 UnicodeString matchString = fields[1]; 4109 matchString.findAndReplace(nulnulSrc, nulnul); 4110 matchString.findAndReplace(ffffSrc, ffff); 4111 4112 // Replace any \n in the match string with an actual new-line char. 4113 // Don't do full unescape, as this unescapes more than Perl does, which 4114 // causes other spurious failures in the tests. 4115 matchString.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n"); 4116 4117 4118 4119 // 4120 // Run the test, check for expected match/don't match result. 4121 // 4122 RegexMatcher *testMat = testPat->matcher(matchString, status); 4123 UBool found = testMat->find(); 4124 UBool expected = FALSE; 4125 if (fields[2].indexOf(UChar_y) >=0) { 4126 expected = TRUE; 4127 } 4128 if (expected != found) { 4129 errln("line %d: Expected %smatch, got %smatch", 4130 lineNum, expected?"":"no ", found?"":"no " ); 4131 continue; 4132 } 4133 4134 // Don't try to check expected results if there is no match. 4135 // (Some have stuff in the expected fields) 4136 if (!found) { 4137 delete testMat; 4138 delete testPat; 4139 continue; 4140 } 4141 4142 // 4143 // Interpret the Perl expression from the fourth field of the data file, 4144 // building up an ICU string from the results of the ICU match. 4145 // The Perl expression will contain references to the results of 4146 // a regex match, including the matched string, capture group strings, 4147 // group starting and ending indicies, etc. 4148 // 4149 UnicodeString resultString; 4150 UnicodeString perlExpr = fields[3]; 4151 #if SUPPORT_MUTATING_INPUT_STRING 4152 groupsMat->reset(perlExpr); 4153 cgMat->reset(perlExpr); 4154 #endif 4155 4156 while (perlExpr.length() > 0) { 4157 #if !SUPPORT_MUTATING_INPUT_STRING 4158 // Perferred usage. Reset after any modification to input string. 4159 groupsMat->reset(perlExpr); 4160 cgMat->reset(perlExpr); 4161 #endif 4162 4163 if (perlExpr.startsWith("$&")) { 4164 resultString.append(testMat->group(status)); 4165 perlExpr.remove(0, 2); 4166 } 4167 4168 else if (groupsMat->lookingAt(status)) { 4169 // $-[0] $+[2] etc. 4170 UnicodeString digitString = groupsMat->group(2, status); 4171 int32_t t = 0; 4172 int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10); 4173 UnicodeString plusOrMinus = groupsMat->group(1, status); 4174 int32_t matchPosition; 4175 if (plusOrMinus.compare("+") == 0) { 4176 matchPosition = testMat->end(groupNum, status); 4177 } else { 4178 matchPosition = testMat->start(groupNum, status); 4179 } 4180 if (matchPosition != -1) { 4181 ICU_Utility::appendNumber(resultString, matchPosition); 4182 } 4183 perlExpr.remove(0, groupsMat->end(status)); 4184 } 4185 4186 else if (cgMat->lookingAt(status)) { 4187 // $1, $2, $3, etc. 4188 UnicodeString digitString = cgMat->group(1, status); 4189 int32_t t = 0; 4190 int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10); 4191 if (U_SUCCESS(status)) { 4192 resultString.append(testMat->group(groupNum, status)); 4193 status = U_ZERO_ERROR; 4194 } 4195 perlExpr.remove(0, cgMat->end(status)); 4196 } 4197 4198 else if (perlExpr.startsWith("@-")) { 4199 int32_t i; 4200 for (i=0; i<=testMat->groupCount(); i++) { 4201 if (i>0) { 4202 resultString.append(" "); 4203 } 4204 ICU_Utility::appendNumber(resultString, testMat->start(i, status)); 4205 } 4206 perlExpr.remove(0, 2); 4207 } 4208 4209 else if (perlExpr.startsWith("@+")) { 4210 int32_t i; 4211 for (i=0; i<=testMat->groupCount(); i++) { 4212 if (i>0) { 4213 resultString.append(" "); 4214 } 4215 ICU_Utility::appendNumber(resultString, testMat->end(i, status)); 4216 } 4217 perlExpr.remove(0, 2); 4218 } 4219 4220 else if (perlExpr.startsWith(UNICODE_STRING_SIMPLE("\\"))) { // \Escape. Take following char as a literal. 4221 // or as an escaped sequence (e.g. \n) 4222 if (perlExpr.length() > 1) { 4223 perlExpr.remove(0, 1); // Remove the '\', but only if not last char. 4224 } 4225 UChar c = perlExpr.charAt(0); 4226 switch (c) { 4227 case 'n': c = '\n'; break; 4228 // add any other escape sequences that show up in the test expected results. 4229 } 4230 resultString.append(c); 4231 perlExpr.remove(0, 1); 4232 } 4233 4234 else { 4235 // Any characters from the perl expression that we don't explicitly 4236 // recognize before here are assumed to be literals and copied 4237 // as-is to the expected results. 4238 resultString.append(perlExpr.charAt(0)); 4239 perlExpr.remove(0, 1); 4240 } 4241 4242 if (U_FAILURE(status)) { 4243 errln("Line %d: ICU Error \"%s\"", lineNum, u_errorName(status)); 4244 break; 4245 } 4246 } 4247 4248 // 4249 // Expected Results Compare 4250 // 4251 UnicodeString expectedS(fields[4]); 4252 expectedS.findAndReplace(nulnulSrc, nulnul); 4253 expectedS.findAndReplace(ffffSrc, ffff); 4254 expectedS.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n"); 4255 4256 4257 if (expectedS.compare(resultString) != 0) { 4258 err("Line %d: Incorrect perl expression results.", lineNum); 4259 infoln((UnicodeString)"Expected \""+expectedS+(UnicodeString)"\"; got \""+resultString+(UnicodeString)"\""); 4260 } 4261 4262 delete testMat; 4263 delete testPat; 4264 } 4265 4266 // 4267 // All done. Clean up allocated stuff. 4268 // 4269 delete cgMat; 4270 delete cgPat; 4271 4272 delete groupsMat; 4273 delete groupsPat; 4274 4275 delete flagMat; 4276 delete flagPat; 4277 4278 delete lineMat; 4279 delete linePat; 4280 4281 delete fieldPat; 4282 delete [] testData; 4283 4284 4285 logln("%d tests skipped because of unimplemented regexp features.", skippedUnimplementedCount); 4286 4287 } 4288 4289 4290 //------------------------------------------------------------------------------- 4291 // 4292 // PerlTestsUTF8 Run Perl's regular expression tests on UTF-8-based UTexts 4293 // (instead of using UnicodeStrings) to test the alternate engine. 4294 // The input file for this test is re_tests, the standard regular 4295 // expression test data distributed with the Perl source code. 4296 // See PerlTests() for more information. 4297 // 4298 //------------------------------------------------------------------------------- 4299 void RegexTest::PerlTestsUTF8() { 4300 char tdd[2048]; 4301 const char *srcPath; 4302 UErrorCode status = U_ZERO_ERROR; 4303 UParseError pe; 4304 LocalUConverterPointer UTF8Converter(ucnv_open("UTF-8", &status)); 4305 UText patternText = UTEXT_INITIALIZER; 4306 char *patternChars = NULL; 4307 int32_t patternLength; 4308 int32_t patternCapacity = 0; 4309 UText inputText = UTEXT_INITIALIZER; 4310 char *inputChars = NULL; 4311 int32_t inputLength; 4312 int32_t inputCapacity = 0; 4313 4314 ucnv_setFromUCallBack(UTF8Converter.getAlias(), UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status); 4315 4316 // 4317 // Open and read the test data file. 4318 // 4319 srcPath=getPath(tdd, "re_tests.txt"); 4320 if(srcPath==NULL) { 4321 return; /* something went wrong, error already output */ 4322 } 4323 4324 int32_t len; 4325 UChar *testData = ReadAndConvertFile(srcPath, len, "iso-8859-1", status); 4326 if (U_FAILURE(status)) { 4327 return; /* something went wrong, error already output */ 4328 } 4329 4330 // 4331 // Put the test data into a UnicodeString 4332 // 4333 UnicodeString testDataString(FALSE, testData, len); 4334 4335 // 4336 // Regex to break the input file into lines, and strip the new lines. 4337 // One line per match, capture group one is the desired data. 4338 // 4339 RegexPattern* linePat = RegexPattern::compile(UNICODE_STRING_SIMPLE("(.+?)[\\r\\n]+"), 0, pe, status); 4340 if (U_FAILURE(status)) { 4341 dataerrln("RegexPattern::compile() error"); 4342 return; 4343 } 4344 RegexMatcher* lineMat = linePat->matcher(testDataString, status); 4345 4346 // 4347 // Regex to split a test file line into fields. 4348 // There are six fields, separated by tabs. 4349 // 4350 RegexPattern* fieldPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\t"), 0, pe, status); 4351 4352 // 4353 // Regex to identify test patterns with flag settings, and to separate them. 4354 // Test patterns with flags look like 'pattern'i 4355 // Test patterns without flags are not quoted: pattern 4356 // Coming out, capture group 2 is the pattern, capture group 3 is the flags. 4357 // 4358 RegexPattern *flagPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("('?)(.*)\\1(.*)"), 0, pe, status); 4359 RegexMatcher* flagMat = flagPat->matcher(status); 4360 4361 // 4362 // The Perl tests reference several perl-isms, which are evaluated/substituted 4363 // in the test data. Not being perl, this must be done explicitly. Here 4364 // are string constants and REs for these constructs. 4365 // 4366 UnicodeString nulnulSrc("${nulnul}"); 4367 UnicodeString nulnul("\\u0000\\u0000", -1, US_INV); 4368 nulnul = nulnul.unescape(); 4369 4370 UnicodeString ffffSrc("${ffff}"); 4371 UnicodeString ffff("\\uffff", -1, US_INV); 4372 ffff = ffff.unescape(); 4373 4374 // regexp for $-[0], $+[2], etc. 4375 RegexPattern *groupsPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$([+\\-])\\[(\\d+)\\]"), 0, pe, status); 4376 RegexMatcher *groupsMat = groupsPat->matcher(status); 4377 4378 // regexp for $0, $1, $2, etc. 4379 RegexPattern *cgPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$(\\d+)"), 0, pe, status); 4380 RegexMatcher *cgMat = cgPat->matcher(status); 4381 4382 4383 // 4384 // Main Loop for the Perl Tests, runs once per line from the 4385 // test data file. 4386 // 4387 int32_t lineNum = 0; 4388 int32_t skippedUnimplementedCount = 0; 4389 while (lineMat->find()) { 4390 lineNum++; 4391 4392 // 4393 // Get a line, break it into its fields, do the Perl 4394 // variable substitutions. 4395 // 4396 UnicodeString line = lineMat->group(1, status); 4397 UnicodeString fields[7]; 4398 fieldPat->split(line, fields, 7, status); 4399 4400 flagMat->reset(fields[0]); 4401 flagMat->matches(status); 4402 UnicodeString pattern = flagMat->group(2, status); 4403 pattern.findAndReplace("${bang}", "!"); 4404 pattern.findAndReplace(nulnulSrc, UNICODE_STRING_SIMPLE("\\u0000\\u0000")); 4405 pattern.findAndReplace(ffffSrc, ffff); 4406 4407 // 4408 // Identify patterns that include match flag settings, 4409 // split off the flags, remove the extra quotes. 4410 // 4411 UnicodeString flagStr = flagMat->group(3, status); 4412 if (U_FAILURE(status)) { 4413 errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status)); 4414 return; 4415 } 4416 int32_t flags = 0; 4417 const UChar UChar_c = 0x63; // Char constants for the flag letters. 4418 const UChar UChar_i = 0x69; // (Damn the lack of Unicode support in C) 4419 const UChar UChar_m = 0x6d; 4420 const UChar UChar_x = 0x78; 4421 const UChar UChar_y = 0x79; 4422 if (flagStr.indexOf(UChar_i) != -1) { 4423 flags |= UREGEX_CASE_INSENSITIVE; 4424 } 4425 if (flagStr.indexOf(UChar_m) != -1) { 4426 flags |= UREGEX_MULTILINE; 4427 } 4428 if (flagStr.indexOf(UChar_x) != -1) { 4429 flags |= UREGEX_COMMENTS; 4430 } 4431 4432 // 4433 // Put the pattern in a UTF-8 UText 4434 // 4435 status = U_ZERO_ERROR; 4436 patternLength = pattern.extract(patternChars, patternCapacity, UTF8Converter.getAlias(), status); 4437 if (status == U_BUFFER_OVERFLOW_ERROR) { 4438 status = U_ZERO_ERROR; 4439 delete[] patternChars; 4440 patternCapacity = patternLength + 1; 4441 patternChars = new char[patternCapacity]; 4442 pattern.extract(patternChars, patternCapacity, UTF8Converter.getAlias(), status); 4443 } 4444 utext_openUTF8(&patternText, patternChars, patternLength, &status); 4445 4446 // 4447 // Compile the test pattern. 4448 // 4449 RegexPattern *testPat = RegexPattern::compile(&patternText, flags, pe, status); 4450 if (status == U_REGEX_UNIMPLEMENTED) { 4451 // 4452 // Test of a feature that is planned for ICU, but not yet implemented. 4453 // skip the test. 4454 skippedUnimplementedCount++; 4455 delete testPat; 4456 status = U_ZERO_ERROR; 4457 continue; 4458 } 4459 4460 if (U_FAILURE(status)) { 4461 // Some tests are supposed to generate errors. 4462 // Only report an error for tests that are supposed to succeed. 4463 if (fields[2].indexOf(UChar_c) == -1 && // Compilation is not supposed to fail AND 4464 fields[2].indexOf(UChar_i) == -1) // it's not an accepted ICU incompatibility 4465 { 4466 errln("line %d: ICU Error \"%s\"\n", lineNum, u_errorName(status)); 4467 } 4468 status = U_ZERO_ERROR; 4469 delete testPat; 4470 continue; 4471 } 4472 4473 if (fields[2].indexOf(UChar_i) >= 0) { 4474 // ICU should skip this test. 4475 delete testPat; 4476 continue; 4477 } 4478 4479 if (fields[2].indexOf(UChar_c) >= 0) { 4480 // This pattern should have caused a compilation error, but didn't/ 4481 errln("line %d: Expected a pattern compile error, got success.", lineNum); 4482 delete testPat; 4483 continue; 4484 } 4485 4486 4487 // 4488 // replace the Perl variables that appear in some of the 4489 // match data strings. 4490 // 4491 UnicodeString matchString = fields[1]; 4492 matchString.findAndReplace(nulnulSrc, nulnul); 4493 matchString.findAndReplace(ffffSrc, ffff); 4494 4495 // Replace any \n in the match string with an actual new-line char. 4496 // Don't do full unescape, as this unescapes more than Perl does, which 4497 // causes other spurious failures in the tests. 4498 matchString.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n"); 4499 4500 // 4501 // Put the input in a UTF-8 UText 4502 // 4503 status = U_ZERO_ERROR; 4504 inputLength = matchString.extract(inputChars, inputCapacity, UTF8Converter.getAlias(), status); 4505 if (status == U_BUFFER_OVERFLOW_ERROR) { 4506 status = U_ZERO_ERROR; 4507 delete[] inputChars; 4508 inputCapacity = inputLength + 1; 4509 inputChars = new char[inputCapacity]; 4510 matchString.extract(inputChars, inputCapacity, UTF8Converter.getAlias(), status); 4511 } 4512 utext_openUTF8(&inputText, inputChars, inputLength, &status); 4513 4514 // 4515 // Run the test, check for expected match/don't match result. 4516 // 4517 RegexMatcher *testMat = &testPat->matcher(status)->reset(&inputText); 4518 UBool found = testMat->find(); 4519 UBool expected = FALSE; 4520 if (fields[2].indexOf(UChar_y) >=0) { 4521 expected = TRUE; 4522 } 4523 if (expected != found) { 4524 errln("line %d: Expected %smatch, got %smatch", 4525 lineNum, expected?"":"no ", found?"":"no " ); 4526 continue; 4527 } 4528 4529 // Don't try to check expected results if there is no match. 4530 // (Some have stuff in the expected fields) 4531 if (!found) { 4532 delete testMat; 4533 delete testPat; 4534 continue; 4535 } 4536 4537 // 4538 // Interpret the Perl expression from the fourth field of the data file, 4539 // building up an ICU string from the results of the ICU match. 4540 // The Perl expression will contain references to the results of 4541 // a regex match, including the matched string, capture group strings, 4542 // group starting and ending indicies, etc. 4543 // 4544 UnicodeString resultString; 4545 UnicodeString perlExpr = fields[3]; 4546 4547 while (perlExpr.length() > 0) { 4548 groupsMat->reset(perlExpr); 4549 cgMat->reset(perlExpr); 4550 4551 if (perlExpr.startsWith("$&")) { 4552 resultString.append(testMat->group(status)); 4553 perlExpr.remove(0, 2); 4554 } 4555 4556 else if (groupsMat->lookingAt(status)) { 4557 // $-[0] $+[2] etc. 4558 UnicodeString digitString = groupsMat->group(2, status); 4559 int32_t t = 0; 4560 int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10); 4561 UnicodeString plusOrMinus = groupsMat->group(1, status); 4562 int32_t matchPosition; 4563 if (plusOrMinus.compare("+") == 0) { 4564 matchPosition = testMat->end(groupNum, status); 4565 } else { 4566 matchPosition = testMat->start(groupNum, status); 4567 } 4568 if (matchPosition != -1) { 4569 ICU_Utility::appendNumber(resultString, matchPosition); 4570 } 4571 perlExpr.remove(0, groupsMat->end(status)); 4572 } 4573 4574 else if (cgMat->lookingAt(status)) { 4575 // $1, $2, $3, etc. 4576 UnicodeString digitString = cgMat->group(1, status); 4577 int32_t t = 0; 4578 int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10); 4579 if (U_SUCCESS(status)) { 4580 resultString.append(testMat->group(groupNum, status)); 4581 status = U_ZERO_ERROR; 4582 } 4583 perlExpr.remove(0, cgMat->end(status)); 4584 } 4585 4586 else if (perlExpr.startsWith("@-")) { 4587 int32_t i; 4588 for (i=0; i<=testMat->groupCount(); i++) { 4589 if (i>0) { 4590 resultString.append(" "); 4591 } 4592 ICU_Utility::appendNumber(resultString, testMat->start(i, status)); 4593 } 4594 perlExpr.remove(0, 2); 4595 } 4596 4597 else if (perlExpr.startsWith("@+")) { 4598 int32_t i; 4599 for (i=0; i<=testMat->groupCount(); i++) { 4600 if (i>0) { 4601 resultString.append(" "); 4602 } 4603 ICU_Utility::appendNumber(resultString, testMat->end(i, status)); 4604 } 4605 perlExpr.remove(0, 2); 4606 } 4607 4608 else if (perlExpr.startsWith(UNICODE_STRING_SIMPLE("\\"))) { // \Escape. Take following char as a literal. 4609 // or as an escaped sequence (e.g. \n) 4610 if (perlExpr.length() > 1) { 4611 perlExpr.remove(0, 1); // Remove the '\', but only if not last char. 4612 } 4613 UChar c = perlExpr.charAt(0); 4614 switch (c) { 4615 case 'n': c = '\n'; break; 4616 // add any other escape sequences that show up in the test expected results. 4617 } 4618 resultString.append(c); 4619 perlExpr.remove(0, 1); 4620 } 4621 4622 else { 4623 // Any characters from the perl expression that we don't explicitly 4624 // recognize before here are assumed to be literals and copied 4625 // as-is to the expected results. 4626 resultString.append(perlExpr.charAt(0)); 4627 perlExpr.remove(0, 1); 4628 } 4629 4630 if (U_FAILURE(status)) { 4631 errln("Line %d: ICU Error \"%s\"", lineNum, u_errorName(status)); 4632 break; 4633 } 4634 } 4635 4636 // 4637 // Expected Results Compare 4638 // 4639 UnicodeString expectedS(fields[4]); 4640 expectedS.findAndReplace(nulnulSrc, nulnul); 4641 expectedS.findAndReplace(ffffSrc, ffff); 4642 expectedS.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n"); 4643 4644 4645 if (expectedS.compare(resultString) != 0) { 4646 err("Line %d: Incorrect perl expression results.", lineNum); 4647 infoln((UnicodeString)"Expected \""+expectedS+(UnicodeString)"\"; got \""+resultString+(UnicodeString)"\""); 4648 } 4649 4650 delete testMat; 4651 delete testPat; 4652 } 4653 4654 // 4655 // All done. Clean up allocated stuff. 4656 // 4657 delete cgMat; 4658 delete cgPat; 4659 4660 delete groupsMat; 4661 delete groupsPat; 4662 4663 delete flagMat; 4664 delete flagPat; 4665 4666 delete lineMat; 4667 delete linePat; 4668 4669 delete fieldPat; 4670 delete [] testData; 4671 4672 utext_close(&patternText); 4673 utext_close(&inputText); 4674 4675 delete [] patternChars; 4676 delete [] inputChars; 4677 4678 4679 logln("%d tests skipped because of unimplemented regexp features.", skippedUnimplementedCount); 4680 4681 } 4682 4683 4684 //-------------------------------------------------------------- 4685 // 4686 // Bug6149 Verify limits to heap expansion for backtrack stack. 4687 // Use this pattern, 4688 // "(a?){1,8000000}" 4689 // Note: was an unbounded upperbounds, but that now has loop-breaking enabled. 4690 // This test is likely to be fragile, as further optimizations stop 4691 // more cases of pointless looping in the match engine. 4692 // 4693 //--------------------------------------------------------------- 4694 void RegexTest::Bug6149() { 4695 UnicodeString pattern("(a?){1,8000000}"); 4696 UnicodeString s("xyz"); 4697 uint32_t flags = 0; 4698 UErrorCode status = U_ZERO_ERROR; 4699 4700 RegexMatcher matcher(pattern, s, flags, status); 4701 UBool result = false; 4702 REGEX_ASSERT_FAIL(result=matcher.matches(status), U_REGEX_STACK_OVERFLOW); 4703 REGEX_ASSERT(result == FALSE); 4704 } 4705 4706 4707 // 4708 // Callbacks() Test the callback function. 4709 // When set, callbacks occur periodically during matching operations, 4710 // giving the application code the ability to abort the operation 4711 // before it's normal completion. 4712 // 4713 4714 struct callBackContext { 4715 RegexTest *test; 4716 int32_t maxCalls; 4717 int32_t numCalls; 4718 int32_t lastSteps; 4719 void reset(int32_t max) {maxCalls=max; numCalls=0; lastSteps=0;}; 4720 }; 4721 4722 U_CDECL_BEGIN 4723 static UBool U_CALLCONV 4724 testCallBackFn(const void *context, int32_t steps) { 4725 callBackContext *info = (callBackContext *)context; 4726 if (info->lastSteps+1 != steps) { 4727 info->test->errln("incorrect steps in callback. Expected %d, got %d\n", info->lastSteps+1, steps); 4728 } 4729 info->lastSteps = steps; 4730 info->numCalls++; 4731 return (info->numCalls < info->maxCalls); 4732 } 4733 U_CDECL_END 4734 4735 void RegexTest::Callbacks() { 4736 { 4737 // Getter returns NULLs if no callback has been set 4738 4739 // The variables that the getter will fill in. 4740 // Init to non-null values so that the action of the getter can be seen. 4741 const void *returnedContext = &returnedContext; 4742 URegexMatchCallback *returnedFn = &testCallBackFn; 4743 4744 UErrorCode status = U_ZERO_ERROR; 4745 RegexMatcher matcher("x", 0, status); 4746 REGEX_CHECK_STATUS; 4747 matcher.getMatchCallback(returnedFn, returnedContext, status); 4748 REGEX_CHECK_STATUS; 4749 REGEX_ASSERT(returnedFn == NULL); 4750 REGEX_ASSERT(returnedContext == NULL); 4751 } 4752 4753 { 4754 // Set and Get work 4755 callBackContext cbInfo = {this, 0, 0, 0}; 4756 const void *returnedContext; 4757 URegexMatchCallback *returnedFn; 4758 UErrorCode status = U_ZERO_ERROR; 4759 RegexMatcher matcher(UNICODE_STRING_SIMPLE("((.)+\\2)+x"), 0, status); // A pattern that can run long. 4760 REGEX_CHECK_STATUS; 4761 matcher.setMatchCallback(testCallBackFn, &cbInfo, status); 4762 REGEX_CHECK_STATUS; 4763 matcher.getMatchCallback(returnedFn, returnedContext, status); 4764 REGEX_CHECK_STATUS; 4765 REGEX_ASSERT(returnedFn == testCallBackFn); 4766 REGEX_ASSERT(returnedContext == &cbInfo); 4767 4768 // A short-running match shouldn't invoke the callback 4769 status = U_ZERO_ERROR; 4770 cbInfo.reset(1); 4771 UnicodeString s = "xxx"; 4772 matcher.reset(s); 4773 REGEX_ASSERT(matcher.matches(status)); 4774 REGEX_CHECK_STATUS; 4775 REGEX_ASSERT(cbInfo.numCalls == 0); 4776 4777 // A medium-length match that runs long enough to invoke the 4778 // callback, but not so long that the callback aborts it. 4779 status = U_ZERO_ERROR; 4780 cbInfo.reset(4); 4781 s = "aaaaaaaaaaaaaaaaaaab"; 4782 matcher.reset(s); 4783 REGEX_ASSERT(matcher.matches(status)==FALSE); 4784 REGEX_CHECK_STATUS; 4785 REGEX_ASSERT(cbInfo.numCalls > 0); 4786 4787 // A longer running match that the callback function will abort. 4788 status = U_ZERO_ERROR; 4789 cbInfo.reset(4); 4790 s = "aaaaaaaaaaaaaaaaaaaaaaab"; 4791 matcher.reset(s); 4792 REGEX_ASSERT(matcher.matches(status)==FALSE); 4793 REGEX_ASSERT(status == U_REGEX_STOPPED_BY_CALLER); 4794 REGEX_ASSERT(cbInfo.numCalls == 4); 4795 } 4796 4797 4798 } 4799 4800 4801 // 4802 // FindProgressCallbacks() Test the find "progress" callback function. 4803 // When set, the find progress callback will be invoked during a find operations 4804 // after each return from a match attempt, giving the application the opportunity 4805 // to terminate a long-running find operation before it's normal completion. 4806 // 4807 4808 struct progressCallBackContext { 4809 RegexTest *test; 4810 int64_t lastIndex; 4811 int32_t maxCalls; 4812 int32_t numCalls; 4813 void reset(int32_t max) {maxCalls=max; numCalls=0;lastIndex=0;}; 4814 }; 4815 4816 U_CDECL_BEGIN 4817 static UBool U_CALLCONV 4818 testProgressCallBackFn(const void *context, int64_t matchIndex) { 4819 progressCallBackContext *info = (progressCallBackContext *)context; 4820 info->numCalls++; 4821 info->lastIndex = matchIndex; 4822 // info->test->infoln("ProgressCallback - matchIndex = %d, numCalls = %d\n", matchIndex, info->numCalls); 4823 return (info->numCalls < info->maxCalls); 4824 } 4825 U_CDECL_END 4826 4827 void RegexTest::FindProgressCallbacks() { 4828 { 4829 // Getter returns NULLs if no callback has been set 4830 4831 // The variables that the getter will fill in. 4832 // Init to non-null values so that the action of the getter can be seen. 4833 const void *returnedContext = &returnedContext; 4834 URegexFindProgressCallback *returnedFn = &testProgressCallBackFn; 4835 4836 UErrorCode status = U_ZERO_ERROR; 4837 RegexMatcher matcher("x", 0, status); 4838 REGEX_CHECK_STATUS; 4839 matcher.getFindProgressCallback(returnedFn, returnedContext, status); 4840 REGEX_CHECK_STATUS; 4841 REGEX_ASSERT(returnedFn == NULL); 4842 REGEX_ASSERT(returnedContext == NULL); 4843 } 4844 4845 { 4846 // Set and Get work 4847 progressCallBackContext cbInfo = {this, 0, 0, 0}; 4848 const void *returnedContext; 4849 URegexFindProgressCallback *returnedFn; 4850 UErrorCode status = U_ZERO_ERROR; 4851 RegexMatcher matcher(UNICODE_STRING_SIMPLE("((.)+\\2)+x"), 0, status); // A pattern that can run long. 4852 REGEX_CHECK_STATUS; 4853 matcher.setFindProgressCallback(testProgressCallBackFn, &cbInfo, status); 4854 REGEX_CHECK_STATUS; 4855 matcher.getFindProgressCallback(returnedFn, returnedContext, status); 4856 REGEX_CHECK_STATUS; 4857 REGEX_ASSERT(returnedFn == testProgressCallBackFn); 4858 REGEX_ASSERT(returnedContext == &cbInfo); 4859 4860 // A short-running match should NOT invoke the callback. 4861 status = U_ZERO_ERROR; 4862 cbInfo.reset(100); 4863 UnicodeString s = "abxxx"; 4864 matcher.reset(s); 4865 #if 0 4866 matcher.setTrace(TRUE); 4867 #endif 4868 REGEX_ASSERT(matcher.find(0, status)); 4869 REGEX_CHECK_STATUS; 4870 REGEX_ASSERT(cbInfo.numCalls == 0); 4871 4872 // A medium running match that causes matcher.find() to invoke our callback for each index. 4873 status = U_ZERO_ERROR; 4874 s = "aaaaaaaaaaaaaaaaaaab"; 4875 cbInfo.reset(s.length()); // Some upper limit for number of calls that is greater than size of our input string 4876 matcher.reset(s); 4877 REGEX_ASSERT(matcher.find(0, status)==FALSE); 4878 REGEX_CHECK_STATUS; 4879 REGEX_ASSERT(cbInfo.numCalls > 0 && cbInfo.numCalls < 25); 4880 4881 // A longer running match that causes matcher.find() to invoke our callback which we cancel/interrupt at some point. 4882 status = U_ZERO_ERROR; 4883 UnicodeString s1 = "aaaaaaaaaaaaaaaaaaaaaaab"; 4884 cbInfo.reset(s1.length() - 5); // Bail early somewhere near the end of input string 4885 matcher.reset(s1); 4886 REGEX_ASSERT(matcher.find(0, status)==FALSE); 4887 REGEX_CHECK_STATUS; 4888 REGEX_ASSERT(cbInfo.numCalls == s1.length() - 5); 4889 4890 #if 0 4891 // Now a match that will succeed, but after an interruption 4892 status = U_ZERO_ERROR; 4893 UnicodeString s2 = "aaaaaaaaaaaaaa aaaaaaaaab xxx"; 4894 cbInfo.reset(s2.length() - 10); // Bail early somewhere near the end of input string 4895 matcher.reset(s2); 4896 REGEX_ASSERT(matcher.find(0, status)==FALSE); 4897 REGEX_CHECK_STATUS; 4898 // Now retry the match from where left off 4899 cbInfo.maxCalls = 100; // No callback limit 4900 REGEX_ASSERT(matcher.find(cbInfo.lastIndex, status)); 4901 REGEX_CHECK_STATUS; 4902 #endif 4903 } 4904 4905 4906 } 4907 4908 4909 //--------------------------------------------------------------------------- 4910 // 4911 // PreAllocatedUTextCAPI Check the C API with pre-allocated mutable 4912 // UTexts. The pure-C implementation of UText 4913 // has no mutable backing stores, but we can 4914 // use UnicodeString here to test the functionality. 4915 // 4916 //--------------------------------------------------------------------------- 4917 void RegexTest::PreAllocatedUTextCAPI () { 4918 UErrorCode status = U_ZERO_ERROR; 4919 URegularExpression *re; 4920 UText patternText = UTEXT_INITIALIZER; 4921 UnicodeString buffer; 4922 UText bufferText = UTEXT_INITIALIZER; 4923 4924 utext_openUnicodeString(&bufferText, &buffer, &status); 4925 4926 /* 4927 * getText() and getUText() 4928 */ 4929 { 4930 UText text1 = UTEXT_INITIALIZER; 4931 UText text2 = UTEXT_INITIALIZER; 4932 UChar text2Chars[20]; 4933 UText *resultText; 4934 4935 status = U_ZERO_ERROR; 4936 regextst_openUTF8FromInvariant(&text1, "abcccd", -1, &status); 4937 regextst_openUTF8FromInvariant(&text2, "abcccxd", -1, &status); 4938 u_uastrncpy(text2Chars, "abcccxd", sizeof(text2)/2); 4939 utext_openUChars(&text2, text2Chars, -1, &status); 4940 4941 regextst_openUTF8FromInvariant(&patternText, "abc*d", -1, &status); 4942 re = uregex_openUText(&patternText, 0, NULL, &status); 4943 4944 /* First set a UText */ 4945 uregex_setUText(re, &text1, &status); 4946 resultText = uregex_getUText(re, &bufferText, &status); 4947 REGEX_CHECK_STATUS; 4948 REGEX_ASSERT(resultText == &bufferText); 4949 utext_setNativeIndex(resultText, 0); 4950 utext_setNativeIndex(&text1, 0); 4951 REGEX_ASSERT(testUTextEqual(resultText, &text1)); 4952 4953 resultText = uregex_getUText(re, &bufferText, &status); 4954 REGEX_CHECK_STATUS; 4955 REGEX_ASSERT(resultText == &bufferText); 4956 utext_setNativeIndex(resultText, 0); 4957 utext_setNativeIndex(&text1, 0); 4958 REGEX_ASSERT(testUTextEqual(resultText, &text1)); 4959 4960 /* Then set a UChar * */ 4961 uregex_setText(re, text2Chars, 7, &status); 4962 resultText = uregex_getUText(re, &bufferText, &status); 4963 REGEX_CHECK_STATUS; 4964 REGEX_ASSERT(resultText == &bufferText); 4965 utext_setNativeIndex(resultText, 0); 4966 utext_setNativeIndex(&text2, 0); 4967 REGEX_ASSERT(testUTextEqual(resultText, &text2)); 4968 4969 uregex_close(re); 4970 utext_close(&text1); 4971 utext_close(&text2); 4972 } 4973 4974 /* 4975 * group() 4976 */ 4977 { 4978 UChar text1[80]; 4979 UText *actual; 4980 UBool result; 4981 u_uastrncpy(text1, "noise abc interior def, and this is off the end", sizeof(text1)/2); 4982 4983 status = U_ZERO_ERROR; 4984 re = uregex_openC("abc(.*?)def", 0, NULL, &status); 4985 REGEX_CHECK_STATUS; 4986 4987 uregex_setText(re, text1, -1, &status); 4988 result = uregex_find(re, 0, &status); 4989 REGEX_ASSERT(result==TRUE); 4990 4991 /* Capture Group 0, the full match. Should succeed. */ 4992 status = U_ZERO_ERROR; 4993 actual = uregex_groupUTextDeep(re, 0, &bufferText, &status); 4994 REGEX_CHECK_STATUS; 4995 REGEX_ASSERT(actual == &bufferText); 4996 REGEX_ASSERT_UTEXT_INVARIANT("abc interior def", actual); 4997 4998 /* Capture group #1. Should succeed. */ 4999 status = U_ZERO_ERROR; 5000 actual = uregex_groupUTextDeep(re, 1, &bufferText, &status); 5001 REGEX_CHECK_STATUS; 5002 REGEX_ASSERT(actual == &bufferText); 5003 REGEX_ASSERT_UTEXT_INVARIANT(" interior ", actual); 5004 5005 /* Capture group out of range. Error. */ 5006 status = U_ZERO_ERROR; 5007 actual = uregex_groupUTextDeep(re, 2, &bufferText, &status); 5008 REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 5009 REGEX_ASSERT(actual == &bufferText); 5010 5011 uregex_close(re); 5012 5013 } 5014 5015 /* 5016 * replaceFirst() 5017 */ 5018 { 5019 UChar text1[80]; 5020 UChar text2[80]; 5021 UText replText = UTEXT_INITIALIZER; 5022 UText *result; 5023 5024 status = U_ZERO_ERROR; 5025 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 5026 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 5027 regextst_openUTF8FromInvariant(&replText, "<$1>", -1, &status); 5028 5029 re = uregex_openC("x(.*?)x", 0, NULL, &status); 5030 REGEX_CHECK_STATUS; 5031 5032 /* Normal case, with match */ 5033 uregex_setText(re, text1, -1, &status); 5034 utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status); 5035 result = uregex_replaceFirstUText(re, &replText, &bufferText, &status); 5036 REGEX_CHECK_STATUS; 5037 REGEX_ASSERT(result == &bufferText); 5038 REGEX_ASSERT_UTEXT_INVARIANT("Replace <aa> x1x x...x.", result); 5039 5040 /* No match. Text should copy to output with no changes. */ 5041 uregex_setText(re, text2, -1, &status); 5042 utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status); 5043 result = uregex_replaceFirstUText(re, &replText, &bufferText, &status); 5044 REGEX_CHECK_STATUS; 5045 REGEX_ASSERT(result == &bufferText); 5046 REGEX_ASSERT_UTEXT_INVARIANT("No match here.", result); 5047 5048 /* Unicode escapes */ 5049 uregex_setText(re, text1, -1, &status); 5050 regextst_openUTF8FromInvariant(&replText, "\\\\\\u0041$1\\U00000042$\\a", -1, &status); 5051 utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status); 5052 result = uregex_replaceFirstUText(re, &replText, &bufferText, &status); 5053 REGEX_CHECK_STATUS; 5054 REGEX_ASSERT(result == &bufferText); 5055 REGEX_ASSERT_UTEXT_INVARIANT("Replace \\AaaB$a x1x x...x.", result); 5056 5057 uregex_close(re); 5058 utext_close(&replText); 5059 } 5060 5061 5062 /* 5063 * replaceAll() 5064 */ 5065 { 5066 UChar text1[80]; 5067 UChar text2[80]; 5068 UText replText = UTEXT_INITIALIZER; 5069 UText *result; 5070 5071 status = U_ZERO_ERROR; 5072 u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2); 5073 u_uastrncpy(text2, "No match here.", sizeof(text2)/2); 5074 regextst_openUTF8FromInvariant(&replText, "<$1>", -1, &status); 5075 5076 re = uregex_openC("x(.*?)x", 0, NULL, &status); 5077 REGEX_CHECK_STATUS; 5078 5079 /* Normal case, with match */ 5080 uregex_setText(re, text1, -1, &status); 5081 utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status); 5082 result = uregex_replaceAllUText(re, &replText, &bufferText, &status); 5083 REGEX_CHECK_STATUS; 5084 REGEX_ASSERT(result == &bufferText); 5085 REGEX_ASSERT_UTEXT_INVARIANT("Replace <aa> <1> <...>.", result); 5086 5087 /* No match. Text should copy to output with no changes. */ 5088 uregex_setText(re, text2, -1, &status); 5089 utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status); 5090 result = uregex_replaceAllUText(re, &replText, &bufferText, &status); 5091 REGEX_CHECK_STATUS; 5092 REGEX_ASSERT(result == &bufferText); 5093 REGEX_ASSERT_UTEXT_INVARIANT("No match here.", result); 5094 5095 uregex_close(re); 5096 utext_close(&replText); 5097 } 5098 5099 5100 /* 5101 * splitUText() uses the C++ API directly, and the UnicodeString version uses mutable UTexts, 5102 * so we don't need to test it here. 5103 */ 5104 5105 utext_close(&bufferText); 5106 utext_close(&patternText); 5107 } 5108 5109 //-------------------------------------------------------------- 5110 // 5111 // Bug7651 Regex pattern that exceeds default operator stack depth in matcher. 5112 // 5113 //--------------------------------------------------------------- 5114 void RegexTest::Bug7651() { 5115 UnicodeString pattern1("((?<![A-Za-z0-9])[#\\uff03][A-Za-z0-9_][A-Za-z0-9_\\u00c0-\\u00d6\\u00c8-\\u00f6\\u00f8-\\u00ff]*|(?<![A-Za-z0-9_])[@\\uff20][A-Za-z0-9_]+(?:\\/[\\w-]+)?|(https?\\:\\/\\/|www\\.)\\S+(?<![\\!\\),\\.:;\\]\\u0080-\\uFFFF])|\\$[A-Za-z]+)"); 5116 // The following should exceed the default operator stack depth in the matcher, i.e. force the matcher to malloc instead of using fSmallData. 5117 // It will cause a segfault if RegexMatcher tries to use fSmallData instead of malloc'ing the memory needed (see init2) for the pattern operator stack allocation. 5118 UnicodeString pattern2("((https?\\:\\/\\/|www\\.)\\S+(?<![\\!\\),\\.:;\\]\\u0080-\\uFFFF])|(?<![A-Za-z0-9_])[\\@\\uff20][A-Za-z0-9_]+(?:\\/[\\w\\-]+)?|(?<![A-Za-z0-9])[\\#\\uff03][A-Za-z0-9_][A-Za-z0-9_\\u00c0-\\u00d6\\u00c8-\\u00f6\\u00f8-\\u00ff]*|\\$[A-Za-z]+)"); 5119 UnicodeString s("#ff @abcd This is test"); 5120 RegexPattern *REPattern = NULL; 5121 RegexMatcher *REMatcher = NULL; 5122 UErrorCode status = U_ZERO_ERROR; 5123 UParseError pe; 5124 5125 REPattern = RegexPattern::compile(pattern1, 0, pe, status); 5126 REGEX_CHECK_STATUS; 5127 REMatcher = REPattern->matcher(s, status); 5128 REGEX_CHECK_STATUS; 5129 REGEX_ASSERT(REMatcher->find()); 5130 REGEX_ASSERT(REMatcher->start(status) == 0); 5131 delete REPattern; 5132 delete REMatcher; 5133 status = U_ZERO_ERROR; 5134 5135 REPattern = RegexPattern::compile(pattern2, 0, pe, status); 5136 REGEX_CHECK_STATUS; 5137 REMatcher = REPattern->matcher(s, status); 5138 REGEX_CHECK_STATUS; 5139 REGEX_ASSERT(REMatcher->find()); 5140 REGEX_ASSERT(REMatcher->start(status) == 0); 5141 delete REPattern; 5142 delete REMatcher; 5143 status = U_ZERO_ERROR; 5144 } 5145 5146 void RegexTest::Bug7740() { 5147 UErrorCode status = U_ZERO_ERROR; 5148 UnicodeString pattern = "(a)"; 5149 UnicodeString text = "abcdef"; 5150 RegexMatcher *m = new RegexMatcher(pattern, text, 0, status); 5151 REGEX_CHECK_STATUS; 5152 REGEX_ASSERT(m->lookingAt(status)); 5153 REGEX_CHECK_STATUS; 5154 status = U_ILLEGAL_ARGUMENT_ERROR; 5155 UnicodeString s = m->group(1, status); // Bug 7740: segfault here. 5156 REGEX_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 5157 REGEX_ASSERT(s == ""); 5158 delete m; 5159 } 5160 5161 // Bug 8479: was crashing whith a Bogus UnicodeString as input. 5162 5163 void RegexTest::Bug8479() { 5164 UErrorCode status = U_ZERO_ERROR; 5165 5166 RegexMatcher* const pMatcher = new RegexMatcher("\\Aboo\\z", UREGEX_DOTALL|UREGEX_CASE_INSENSITIVE, status); 5167 REGEX_CHECK_STATUS; 5168 if (U_SUCCESS(status)) 5169 { 5170 UnicodeString str; 5171 str.setToBogus(); 5172 pMatcher->reset(str); 5173 status = U_ZERO_ERROR; 5174 pMatcher->matches(status); 5175 REGEX_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 5176 delete pMatcher; 5177 } 5178 } 5179 5180 5181 // Bug 7029 5182 void RegexTest::Bug7029() { 5183 UErrorCode status = U_ZERO_ERROR; 5184 5185 RegexMatcher* const pMatcher = new RegexMatcher(".", 0, status); 5186 UnicodeString text = "abc.def"; 5187 UnicodeString splits[10]; 5188 REGEX_CHECK_STATUS; 5189 int32_t numFields = pMatcher->split(text, splits, 10, status); 5190 REGEX_CHECK_STATUS; 5191 REGEX_ASSERT(numFields == 8); 5192 delete pMatcher; 5193 } 5194 5195 // Bug 9283 5196 // This test is checking for the existance of any supplemental characters that case-fold 5197 // to a bmp character. 5198 // 5199 // At the time of this writing there are none. If any should appear in a subsequent release 5200 // of Unicode, the code in regular expressions compilation that determines the longest 5201 // posssible match for a literal string will need to be enhanced. 5202 // 5203 // See file regexcmp.cpp, case URX_STRING_I in RegexCompile::maxMatchLength() 5204 // for details on what to do in case of a failure of this test. 5205 // 5206 void RegexTest::Bug9283() { 5207 UErrorCode status = U_ZERO_ERROR; 5208 UnicodeSet supplementalsWithCaseFolding("[[:CWCF:]&[\\U00010000-\\U0010FFFF]]", status); 5209 REGEX_CHECK_STATUS; 5210 int32_t index; 5211 UChar32 c; 5212 for (index=0; ; index++) { 5213 c = supplementalsWithCaseFolding.charAt(index); 5214 if (c == -1) { 5215 break; 5216 } 5217 UnicodeString cf = UnicodeString(c).foldCase(); 5218 REGEX_ASSERT(cf.length() >= 2); 5219 } 5220 } 5221 5222 5223 void RegexTest::CheckInvBufSize() { 5224 if(inv_next>=INV_BUFSIZ) { 5225 errln("%s: increase #define of INV_BUFSIZ ( is %d but needs to be at least %d )\n", 5226 __FILE__, INV_BUFSIZ, inv_next); 5227 } else { 5228 logln("%s: INV_BUFSIZ is %d, usage %d\n", __FILE__, INV_BUFSIZ, inv_next); 5229 } 5230 } 5231 5232 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */ 5233 5234
