AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cb079e90d2
scuffed-code/icu4c/source/test/intltest/regextst.cpp

4764 lines
166 KiB
C++
Raw Normal View History

ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
/********************************************************************
* COPYRIGHT:
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
* Copyright (c) 2002-2010, International Business Machines Corporation and
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
* others. All Rights Reserved.
********************************************************************/
//
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
// regextst.cpp
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//
// ICU Regular Expressions test, part of intltest.
//
ICU-3326 Improve build time X-SVN-Rev: 13427
2003-10-15 08:03:56 +00:00
#include "intltest.h"
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10180
2002-11-07 02:34:46 +00:00
#if !UCONFIG_NO_REGULAR_EXPRESSIONS
ICU-3326 Don't include some unneeded headers. X-SVN-Rev: 13965
2003-12-03 06:58:28 +00:00
#include "unicode/regex.h"
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
#include "unicode/uchar.h"
ICU-5617 Revert encoding detection code for z/OS. X-SVN-Rev: 22057
2007-07-19 16:41:48 +00:00
#include "unicode/ucnv.h"
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
#include "unicode/ustring.h"
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
#include "regextst.h"
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
#include "uvector.h"
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
#include "util.h"
ICU-3326 Improve build time X-SVN-Rev: 13427
2003-10-15 08:03:56 +00:00
#include <stdlib.h>
ICU-4092 Remove dead code. Don't use codepage specific CharString. There are other ways to achieve the same results. X-SVN-Rev: 16991
2004-12-22 00:05:59 +00:00
#include <string.h>
ICU-3326 Improve build time X-SVN-Rev: 13427
2003-10-15 08:03:56 +00:00
#include <stdio.h>
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
#define SUPPORT_MUTATING_INPUT_STRING 0
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//---------------------------------------------------------------------------
//
// Test class boilerplate
//
//---------------------------------------------------------------------------
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
RegexTest::RegexTest()
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
{
ICU-4288 Mostly fixes for --enable-strict for gcc 3.4 (Fedora Core 3) X-SVN-Rev: 17040
2004-12-30 07:25:51 +00:00
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
RegexTest::~RegexTest()
{
ICU-4288 Mostly fixes for --enable-strict for gcc 3.4 (Fedora Core 3) X-SVN-Rev: 17040
2004-12-30 07:25:51 +00:00
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
void RegexTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
if (exec) logln("TestSuite RegexTest: ");
switch (index) {
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10063
2002-10-24 22:16:07 +00:00
case 0: name = "Basic";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) Basic();
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
break;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10063
2002-10-24 22:16:07 +00:00
case 1: name = "API_Match";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) API_Match();
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10063
2002-10-24 22:16:07 +00:00
break;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
case 2: name = "API_Replace";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) API_Replace();
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
break;
case 3: name = "API_Pattern";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) API_Pattern();
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
break;
ICU-7068 Add statements to ensure that uconfigtest passes X-SVN-Rev: 26466
2009-08-04 21:09:17 +00:00
case 4:
#if !UCONFIG_NO_FILE_IO
name = "Extended";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) Extended();
ICU-7068 Add statements to ensure that uconfigtest passes X-SVN-Rev: 26466
2009-08-04 21:09:17 +00:00
#else
name = "skip";
#endif
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
break;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
case 5: name = "Errors";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
if (exec) Errors();
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
break;
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
case 6: name = "PerlTests";
ICU-2422 regexp, fix a number of bugs uncovered by perl regexp tests. Some still remain. X-SVN-Rev: 10905
2003-01-25 18:57:42 +00:00
if (exec) PerlTests();
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
break;
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
case 7: name = "Callbacks";
ICU-6403 restore original tests for regexp security issues X-SVN-Rev: 24324
2008-06-30 23:53:12 +00:00
if (exec) Callbacks();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 8: name = "FindProgressCallbacks";
if (exec) FindProgressCallbacks();
break;
case 9: name = "Bug 6149";
ICU-6403 restore original tests for regexp security issues X-SVN-Rev: 24324
2008-06-30 23:53:12 +00:00
if (exec) Bug6149();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 10: name = "UTextBasic";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) UTextBasic();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 11: name = "API_Match_UTF8";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) API_Match_UTF8();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 12: name = "API_Replace_UTF8";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) API_Replace_UTF8();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 13: name = "API_Pattern_UTF8";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) API_Pattern_UTF8();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 14: name = "PerlTestsUTF8";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) PerlTestsUTF8();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 15: name = "PreAllocatedUTextCAPI";
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (exec) PreAllocatedUTextCAPI();
break;
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
case 16: name = "Bug 7651";
if (exec) Bug7651();
break;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
default: name = "";
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
break; //needed to end loop
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
}
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//---------------------------------------------------------------------------
//
// Error Checking / Reporting macros used in all of the tests.
//
//---------------------------------------------------------------------------
ICU-6905 Make intltest pass without any data. X-SVN-Rev: 26096
2009-06-12 19:34:21 +00:00
#define REGEX_CHECK_STATUS {if (U_FAILURE(status)) {dataerrln("RegexTest failure at line %d. status=%s", \
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
__LINE__, u_errorName(status)); return;}}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
#define REGEX_ASSERT(expr) {if ((expr)==FALSE) {errln("RegexTest failure at line %d.\n", __LINE__);};}
#define REGEX_ASSERT_FAIL(expr, errcode) {UErrorCode status=U_ZERO_ERROR; (expr);\
ICU-6905 Make intltest pass without any data. X-SVN-Rev: 26096
2009-06-12 19:34:21 +00:00
if (status!=errcode) {dataerrln("RegexTest failure at line %d. Expected status=%s, got %s", \
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
__LINE__, u_errorName(errcode), u_errorName(status));};}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
#define REGEX_CHECK_STATUS_L(line) {if (U_FAILURE(status)) {errln( \
"RegexTest failure at line %d, from %d. status=%d\n",__LINE__, (line), status); }}
#define REGEX_ASSERT_L(expr, line) {if ((expr)==FALSE) { \
errln("RegexTest failure at line %d, from %d.", __LINE__, (line)); return;}}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
void RegexTest::assertUText(const char *expected, UText *actual, const char *file, int line) {
UErrorCode status = U_ZERO_ERROR;
UText expectedText = UTEXT_INITIALIZER;
utext_openUTF8(&expectedText, expected, -1, &status);
utext_setNativeIndex(actual, 0);
if (utext_compare(&expectedText, -1, actual, -1) != 0) {
char buf[201 /*21*/];
char *bufPtr = buf;
UChar32 c = utext_next32From(actual, 0);
while (c != U_SENTINEL && bufPtr < buf+200/*20*/) {
if (0x20<c && c<0x7e) {
*bufPtr = c;
} else {
*bufPtr = '.';
}
bufPtr++;
c = UTEXT_NEXT32(actual);
}
*bufPtr = 0;
errln("Failure at file %s, line %d, expected \"%s\" (%d chars), got \"%s\" (%d chars)", file, line, expected, utext_nativeLength(&expectedText), buf, utext_nativeLength(actual));
}
utext_close(&expectedText);
}
#define REGEX_ASSERT_UTEXT(expected, actual) assertUText((expected), (actual), __FILE__, __LINE__)
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//---------------------------------------------------------------------------
//
// REGEX_TESTLM Macro + invocation function to simplify writing quick tests
// for the LookingAt() and Match() functions.
//
// usage:
// REGEX_TESTLM("pattern", "input text", lookingAt expected, matches expected);
//
// The expected results are UBool - TRUE or FALSE.
// The input text is unescaped. The pattern is not.
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
//
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//
//---------------------------------------------------------------------------
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
#define REGEX_TESTLM(pat, text, looking, match) {doRegexLMTest(pat, text, looking, match, __LINE__);doRegexLMTestUTF8(pat, text, looking, match, __LINE__);}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
UBool RegexTest::doRegexLMTest(const char *pat, const char *text, UBool looking, UBool match, int32_t line) {
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
const UnicodeString pattern(pat, -1, US_INV);
const UnicodeString inputText(text, -1, US_INV);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
RegexPattern *REPattern = NULL;
RegexMatcher *REMatcher = NULL;
UBool retVal = TRUE;
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString patString(pat, -1, US_INV);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
REPattern = RegexPattern::compile(patString, 0, pe, status);
if (U_FAILURE(status)) {
ICU-6905 Make intltest pass without any data. X-SVN-Rev: 26096
2009-06-12 19:34:21 +00:00
dataerrln("RegexTest failure in RegexPattern::compile() at line %d. Status = %s",
ICU-2422 Regexp, general cleanup X-SVN-Rev: 11366
2003-03-20 01:15:10 +00:00
line, u_errorName(status));
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
return FALSE;
}
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
if (line==376) { RegexPatternDump(REPattern);}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
UnicodeString inputString(inputText);
UnicodeString unEscapedInput = inputString.unescape();
REMatcher = REPattern->matcher(unEscapedInput, status);
if (U_FAILURE(status)) {
ICU-2422 Regexp, general cleanup X-SVN-Rev: 11366
2003-03-20 01:15:10 +00:00
errln("RegexTest failure in REPattern::matcher() at line %d. Status = %s\n",
line, u_errorName(status));
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
return FALSE;
}
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
UBool actualmatch;
actualmatch = REMatcher->lookingAt(status);
if (U_FAILURE(status)) {
ICU-2422 Regexp, general cleanup X-SVN-Rev: 11366
2003-03-20 01:15:10 +00:00
errln("RegexTest failure in lookingAt() at line %d. Status = %s\n",
line, u_errorName(status));
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
retVal = FALSE;
}
if (actualmatch != looking) {
errln("RegexTest: wrong return from lookingAt() at line %d.\n", line);
retVal = FALSE;
}
status = U_ZERO_ERROR;
actualmatch = REMatcher->matches(status);
if (U_FAILURE(status)) {
ICU-2422 Regexp, general cleanup X-SVN-Rev: 11366
2003-03-20 01:15:10 +00:00
errln("RegexTest failure in matches() at line %d. Status = %s\n",
line, u_errorName(status));
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
retVal = FALSE;
}
if (actualmatch != match) {
errln("RegexTest: wrong return from matches() at line %d.\n", line);
retVal = FALSE;
}
if (retVal == FALSE) {
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
RegexPatternDump(REPattern);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
}
delete REPattern;
delete REMatcher;
return retVal;
}
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UBool RegexTest::doRegexLMTestUTF8(const char *pat, const char *text, UBool looking, UBool match, int32_t line) {
UText pattern = UTEXT_INITIALIZER;
int32_t inputUTF8Length;
char *textChars = NULL;
UText inputText = UTEXT_INITIALIZER;
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
RegexPattern *REPattern = NULL;
RegexMatcher *REMatcher = NULL;
UBool retVal = TRUE;
utext_openUTF8(&pattern, pat, -1, &status);
REPattern = RegexPattern::compile(&pattern, 0, pe, status);
if (U_FAILURE(status)) {
ICU-7370 Log data errors to ensure that intltest and cintltst passes without data. X-SVN-Rev: 27649
2010-02-24 16:17:03 +00:00
dataerrln("RegexTest failure in RegexPattern::compile() at line %d (UTF8). Status = %s\n",
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
line, u_errorName(status));
return FALSE;
}
UnicodeString inputString(text, -1, US_INV);
UnicodeString unEscapedInput = inputString.unescape();
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
LocalUConverterPointer UTF8Converter(ucnv_open("UTF8", &status));
ucnv_setFromUCallBack(UTF8Converter.getAlias(), UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
inputUTF8Length = unEscapedInput.extract(NULL, 0, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) {
// UTF-8 does not allow unpaired surrogates, so this could actually happen
logln("RegexTest unable to convert input to UTF8 at line %d. Status = %s\n", line, u_errorName(status));
return TRUE; // not a failure of the Regex engine
}
status = U_ZERO_ERROR; // buffer overflow
textChars = new char[inputUTF8Length+1];
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
unEscapedInput.extract(textChars, inputUTF8Length+1, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
utext_openUTF8(&inputText, textChars, inputUTF8Length, &status);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
REMatcher = REPattern->matcher(&inputText, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (U_FAILURE(status)) {
errln("RegexTest failure in REPattern::matcher() at line %d (UTF8). Status = %s\n",
line, u_errorName(status));
return FALSE;
}
UBool actualmatch;
actualmatch = REMatcher->lookingAt(status);
if (U_FAILURE(status)) {
errln("RegexTest failure in lookingAt() at line %d (UTF8). Status = %s\n",
line, u_errorName(status));
retVal = FALSE;
}
if (actualmatch != looking) {
errln("RegexTest: wrong return from lookingAt() at line %d (UTF8).\n", line);
retVal = FALSE;
}
status = U_ZERO_ERROR;
actualmatch = REMatcher->matches(status);
if (U_FAILURE(status)) {
errln("RegexTest failure in matches() at line %d (UTF8). Status = %s\n",
line, u_errorName(status));
retVal = FALSE;
}
if (actualmatch != match) {
errln("RegexTest: wrong return from matches() at line %d (UTF8).\n", line);
retVal = FALSE;
}
if (retVal == FALSE) {
RegexPatternDump(REPattern);
}
delete REPattern;
delete REMatcher;
utext_close(&inputText);
utext_close(&pattern);
ICU-6911 Fix mismatch delete statement. X-SVN-Rev: 27682
2010-02-25 20:38:07 +00:00
delete[] textChars;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
return retVal;
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
//---------------------------------------------------------------------------
//
// REGEX_ERR Macro + invocation function to simplify writing tests
// regex tests for incorrect patterns
//
// usage:
// REGEX_ERR("pattern", expected error line, column, expected status);
//
//---------------------------------------------------------------------------
#define REGEX_ERR(pat, line, col, status) regex_err(pat, line, col, status, __LINE__);
void RegexTest::regex_err(const char *pat, int32_t errLine, int32_t errCol,
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
UErrorCode expectedStatus, int32_t line) {
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
UnicodeString pattern(pat);
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
RegexPattern *callerPattern = NULL;
//
// Compile the caller's pattern
//
UnicodeString patString(pat);
callerPattern = RegexPattern::compile(patString, 0, pe, status);
if (status != expectedStatus) {
ICU-6905 Make intltest pass without any data. X-SVN-Rev: 26096
2009-06-12 19:34:21 +00:00
dataerrln("Line %d: unexpected error %s compiling pattern.", line, u_errorName(status));
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
} else {
if (status != U_ZERO_ERROR) {
if (pe.line != errLine || pe.offset != errCol) {
errln("Line %d: incorrect line/offset from UParseError. Expected %d/%d; got %d/%d.\n",
line, errLine, errCol, pe.line, pe.offset);
}
}
}
delete callerPattern;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Compile again, using a UTF-8-based UText
//
UText patternText = UTEXT_INITIALIZER;
utext_openUTF8(&patternText, pat, -1, &status);
callerPattern = RegexPattern::compile(&patternText, 0, pe, status);
if (status != expectedStatus) {
ICU-7370 Log data errors to ensure that intltest and cintltst passes without data. X-SVN-Rev: 27649
2010-02-24 16:17:03 +00:00
dataerrln("Line %d: unexpected error %s compiling pattern.", line, u_errorName(status));
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
} else {
if (status != U_ZERO_ERROR) {
if (pe.line != errLine || pe.offset != errCol) {
errln("Line %d: incorrect line/offset from UParseError. Expected %d/%d; got %d/%d.\n",
line, errLine, errCol, pe.line, pe.offset);
}
}
}
delete callerPattern;
utext_close(&patternText);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
//---------------------------------------------------------------------------
//
// Basic Check for basic functionality of regex pattern matching.
// Avoid the use of REGEX_FIND test macro, which has
// substantial dependencies on basic Regex functionality.
//
//---------------------------------------------------------------------------
void RegexTest::Basic() {
//
// Debug - slide failing test cases early
//
#if 0
{
ICU-2422 Regexp \N{NAME} added. (ZeroLengthMatch)* optimizations improved. X-SVN-Rev: 11228
2003-03-04 01:10:46 +00:00
// REGEX_TESTLM("a\N{LATIN SMALL LETTER B}c", "abc", FALSE, FALSE);
ICU-2422 regexp, free-format support added, some match mode bugs fixed X-SVN-Rev: 11035
2003-02-13 01:10:22 +00:00
UParseError pe;
ICU-2422 Regexp \N{NAME} added. (ZeroLengthMatch)* optimizations improved. X-SVN-Rev: 11228
2003-03-04 01:10:46 +00:00
UErrorCode status = U_ZERO_ERROR;
RegexPattern::compile("^(?:a?b?)*$", 0, pe, status);
ICU-2422 regexp, free-format support added, some match mode bugs fixed X-SVN-Rev: 11035
2003-02-13 01:10:22 +00:00
// REGEX_FIND("(?>(abc{2,4}?))(c*)", "<0>ab<1>cc</1><2>ccc</2></0>ddd");
// REGEX_FIND("(X([abc=X]+)+X)|(y[abc=]+)", "=XX====================");
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
}
exit(1);
#endif
//
// Pattern with parentheses
//
REGEX_TESTLM("st(abc)ring", "stabcring thing", TRUE, FALSE);
REGEX_TESTLM("st(abc)ring", "stabcring", TRUE, TRUE);
REGEX_TESTLM("st(abc)ring", "stabcrung", FALSE, FALSE);
//
// Patterns with *
//
REGEX_TESTLM("st(abc)*ring", "string", TRUE, TRUE);
REGEX_TESTLM("st(abc)*ring", "stabcring", TRUE, TRUE);
REGEX_TESTLM("st(abc)*ring", "stabcabcring", TRUE, TRUE);
REGEX_TESTLM("st(abc)*ring", "stabcabcdring", FALSE, FALSE);
REGEX_TESTLM("st(abc)*ring", "stabcabcabcring etc.", TRUE, FALSE);
REGEX_TESTLM("a*", "", TRUE, TRUE);
REGEX_TESTLM("a*", "b", TRUE, FALSE);
//
// Patterns with "."
//
REGEX_TESTLM(".", "abc", TRUE, FALSE);
REGEX_TESTLM("...", "abc", TRUE, TRUE);
REGEX_TESTLM("....", "abc", FALSE, FALSE);
REGEX_TESTLM(".*", "abcxyz123", TRUE, TRUE);
REGEX_TESTLM("ab.*xyz", "abcdefghij", FALSE, FALSE);
REGEX_TESTLM("ab.*xyz", "abcdefg...wxyz", TRUE, TRUE);
REGEX_TESTLM("ab.*xyz", "abcde...wxyz...abc..xyz", TRUE, TRUE);
REGEX_TESTLM("ab.*xyz", "abcde...wxyz...abc..xyz...", TRUE, FALSE);
//
// Patterns with * applied to chars at end of literal string
//
REGEX_TESTLM("abc*", "ab", TRUE, TRUE);
REGEX_TESTLM("abc*", "abccccc", TRUE, TRUE);
//
// Supplemental chars match as single chars, not a pair of surrogates.
//
REGEX_TESTLM(".", "\\U00011000", TRUE, TRUE);
REGEX_TESTLM("...", "\\U00011000x\\U00012002", TRUE, TRUE);
REGEX_TESTLM("...", "\\U00011000x\\U00012002y", TRUE, FALSE);
//
// UnicodeSets in the pattern
//
REGEX_TESTLM("[1-6]", "1", TRUE, TRUE);
REGEX_TESTLM("[1-6]", "3", TRUE, TRUE);
REGEX_TESTLM("[1-6]", "7", FALSE, FALSE);
REGEX_TESTLM("a[1-6]", "a3", TRUE, TRUE);
REGEX_TESTLM("a[1-6]", "a3", TRUE, TRUE);
REGEX_TESTLM("a[1-6]b", "a3b", TRUE, TRUE);
REGEX_TESTLM("a[0-9]*b", "a123b", TRUE, TRUE);
REGEX_TESTLM("a[0-9]*b", "abc", TRUE, FALSE);
REGEX_TESTLM("[\\p{Nd}]*", "123456", TRUE, TRUE);
REGEX_TESTLM("[\\p{Nd}]*", "a123456", TRUE, FALSE); // note that * matches 0 occurences.
REGEX_TESTLM("[a][b][[:Zs:]]*", "ab ", TRUE, TRUE);
//
// OR operator in patterns
//
REGEX_TESTLM("(a|b)", "a", TRUE, TRUE);
REGEX_TESTLM("(a|b)", "b", TRUE, TRUE);
REGEX_TESTLM("(a|b)", "c", FALSE, FALSE);
REGEX_TESTLM("a|b", "b", TRUE, TRUE);
REGEX_TESTLM("(a|b|c)*", "aabcaaccbcabc", TRUE, TRUE);
REGEX_TESTLM("(a|b|c)*", "aabcaaccbcabdc", TRUE, FALSE);
REGEX_TESTLM("(a(b|c|d)(x|y|z)*|123)", "ac", TRUE, TRUE);
REGEX_TESTLM("(a(b|c|d)(x|y|z)*|123)", "123", TRUE, TRUE);
REGEX_TESTLM("(a|(1|2)*)(b|c|d)(x|y|z)*|123", "123", TRUE, TRUE);
REGEX_TESTLM("(a|(1|2)*)(b|c|d)(x|y|z)*|123", "222211111czzzzw", TRUE, FALSE);
//
// +
//
REGEX_TESTLM("ab+", "abbc", TRUE, FALSE);
REGEX_TESTLM("ab+c", "ac", FALSE, FALSE);
REGEX_TESTLM("b+", "", FALSE, FALSE);
REGEX_TESTLM("(abc|def)+", "defabc", TRUE, TRUE);
REGEX_TESTLM(".+y", "zippity dooy dah ", TRUE, FALSE);
REGEX_TESTLM(".+y", "zippity dooy", TRUE, TRUE);
//
// ?
//
REGEX_TESTLM("ab?", "ab", TRUE, TRUE);
REGEX_TESTLM("ab?", "a", TRUE, TRUE);
REGEX_TESTLM("ab?", "ac", TRUE, FALSE);
REGEX_TESTLM("ab?", "abb", TRUE, FALSE);
REGEX_TESTLM("a(b|c)?d", "abd", TRUE, TRUE);
REGEX_TESTLM("a(b|c)?d", "acd", TRUE, TRUE);
REGEX_TESTLM("a(b|c)?d", "ad", TRUE, TRUE);
REGEX_TESTLM("a(b|c)?d", "abcd", FALSE, FALSE);
REGEX_TESTLM("a(b|c)?d", "ab", FALSE, FALSE);
//
// Escape sequences that become single literal chars, handled internally
// by ICU's Unescape.
//
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
// REGEX_TESTLM("\101\142", "Ab", TRUE, TRUE); // Octal TODO: not implemented yet.
REGEX_TESTLM("\\a", "\\u0007", TRUE, TRUE); // BEL
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_TESTLM("\\cL", "\\u000c", TRUE, TRUE); // Control-L
REGEX_TESTLM("\\e", "\\u001b", TRUE, TRUE); // Escape
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
REGEX_TESTLM("\\f", "\\u000c", TRUE, TRUE); // Form Feed
REGEX_TESTLM("\\n", "\\u000a", TRUE, TRUE); // new line
REGEX_TESTLM("\\r", "\\u000d", TRUE, TRUE); // CR
REGEX_TESTLM("\\t", "\\u0009", TRUE, TRUE); // Tab
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_TESTLM("\\u1234", "\\u1234", TRUE, TRUE);
REGEX_TESTLM("\\U00001234", "\\u1234", TRUE, TRUE);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
REGEX_TESTLM(".*\\Ax", "xyz", TRUE, FALSE); // \A matches only at the beginning of input
REGEX_TESTLM(".*\\Ax", " xyz", FALSE, FALSE); // \A matches only at the beginning of input
// Escape of special chars in patterns
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_TESTLM("\\\\\\|\\(\\)\\[\\{\\~\\$\\*\\+\\?\\.", "\\\\|()[{~$*+?.", TRUE, TRUE);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//---------------------------------------------------------------------------
//
// UTextBasic Check for quirks that are specific to the UText
// implementation.
//
//---------------------------------------------------------------------------
void RegexTest::UTextBasic() {
UErrorCode status = U_ZERO_ERROR;
UText pattern = UTEXT_INITIALIZER;
utext_openUTF8(&pattern, "abc", -1, &status);
RegexMatcher matcher(&pattern, 0, status);
REGEX_CHECK_STATUS;
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, "abc", -1, &status);
REGEX_CHECK_STATUS;
matcher.reset(&input);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("abc", matcher.inputText());
matcher.reset(matcher.inputText());
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("abc", matcher.inputText());
utext_close(&pattern);
utext_close(&input);
ICU-4288 Mostly fixes for --enable-strict for gcc 3.4 (Fedora Core 3) X-SVN-Rev: 17040
2004-12-30 07:25:51 +00:00
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10076
2002-10-29 01:20:15 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//---------------------------------------------------------------------------
//
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// API_Match Test that the API for class RegexMatcher
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
// is present and nominally working, but excluding functions
// implementing replace operations.
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//
//---------------------------------------------------------------------------
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
void RegexTest::API_Match() {
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
int32_t flags = 0;
//
// Debug - slide failing test cases early
//
#if 0
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
{
}
return;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
#endif
//
// Simple pattern compilation
//
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
{
UnicodeString re("abc");
RegexPattern *pat2;
pat2 = RegexPattern::compile(re, flags, pe, status);
REGEX_CHECK_STATUS;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
UnicodeString inStr1 = "abcdef this is a test";
UnicodeString instr2 = "not abc";
UnicodeString empty = "";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//
// Matcher creation and reset.
//
RegexMatcher *m1 = pat2->matcher(inStr1, status);
REGEX_CHECK_STATUS;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
REGEX_ASSERT(m1->input() == inStr1);
m1->reset(instr2);
REGEX_ASSERT(m1->lookingAt(status) == FALSE);
REGEX_ASSERT(m1->input() == instr2);
m1->reset(inStr1);
REGEX_ASSERT(m1->input() == inStr1);
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
m1->reset(empty);
REGEX_ASSERT(m1->lookingAt(status) == FALSE);
REGEX_ASSERT(m1->input() == empty);
REGEX_ASSERT(&m1->pattern() == pat2);
ICU-3437 test coverage fixes. X-SVN-Rev: 14016
2003-12-05 02:03:13 +00:00
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
//
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// reset(pos, status)
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
//
ICU-3437 test coverage fixes. X-SVN-Rev: 14016
2003-12-05 02:03:13 +00:00
m1->reset(inStr1);
m1->reset(4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m1->input() == inStr1);
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
m1->reset(-1, status);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
m1->reset(0, status);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
int32_t len = m1->input().length();
m1->reset(len-1, status);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
m1->reset(len, status);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
//
// match(pos, status)
//
m1->reset(instr2);
REGEX_ASSERT(m1->matches(4, status) == TRUE);
m1->reset();
REGEX_ASSERT(m1->matches(3, status) == FALSE);
m1->reset();
REGEX_ASSERT(m1->matches(5, status) == FALSE);
REGEX_ASSERT(m1->matches(4, status) == TRUE);
REGEX_ASSERT(m1->matches(-1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
// Match() at end of string should fail, but should not
// be an error.
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
status = U_ZERO_ERROR;
len = m1->input().length();
REGEX_ASSERT(m1->matches(len, status) == FALSE);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
REGEX_CHECK_STATUS;
// Match beyond end of string should fail with an error.
status = U_ZERO_ERROR;
REGEX_ASSERT(m1->matches(len+1, status) == FALSE);
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
// Successful match at end of string.
{
status = U_ZERO_ERROR;
RegexMatcher m("A?", 0, status); // will match zero length string.
REGEX_CHECK_STATUS;
m.reset(inStr1);
len = inStr1.length();
REGEX_ASSERT(m.matches(len, status) == TRUE);
REGEX_CHECK_STATUS;
m.reset(empty);
REGEX_ASSERT(m.matches(0, status) == TRUE);
REGEX_CHECK_STATUS;
}
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
//
// lookingAt(pos, status)
//
status = U_ZERO_ERROR;
m1->reset(instr2); // "not abc"
REGEX_ASSERT(m1->lookingAt(4, status) == TRUE);
REGEX_ASSERT(m1->lookingAt(5, status) == FALSE);
REGEX_ASSERT(m1->lookingAt(3, status) == FALSE);
REGEX_ASSERT(m1->lookingAt(4, status) == TRUE);
REGEX_ASSERT(m1->lookingAt(-1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
len = m1->input().length();
REGEX_ASSERT(m1->lookingAt(len, status) == FALSE);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(m1->lookingAt(len+1, status) == FALSE);
ICU-3437 test coverage fixes, compiler warning fixes. X-SVN-Rev: 14028
2003-12-06 01:49:56 +00:00
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
delete m1;
delete pat2;
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// Capture Group.
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
// RegexMatcher::start();
// RegexMatcher::end();
// RegexMatcher::groupCount();
//
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
UnicodeString re("01(23(45)67)(.*)");
RegexPattern *pat = RegexPattern::compile(re, flags, pe, status);
REGEX_CHECK_STATUS;
UnicodeString data = "0123456789";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
RegexMatcher *matcher = pat->matcher(data, status);
REGEX_CHECK_STATUS;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(matcher->lookingAt(status) == TRUE);
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
static const int32_t matchStarts[] = {0, 2, 4, 8};
static const int32_t matchEnds[] = {10, 8, 6, 10};
int32_t i;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
for (i=0; i<4; i++) {
int32_t actualStart = matcher->start(i, status);
REGEX_CHECK_STATUS;
if (actualStart != matchStarts[i]) {
errln("RegexTest failure at line %d, index %d. Expected %d, got %d\n",
__LINE__, i, matchStarts[i], actualStart);
}
int32_t actualEnd = matcher->end(i, status);
REGEX_CHECK_STATUS;
if (actualEnd != matchEnds[i]) {
errln("RegexTest failure at line %d index %d. Expected %d, got %d\n",
__LINE__, i, matchEnds[i], actualEnd);
}
}
REGEX_ASSERT(matcher->start(0, status) == matcher->start(status));
REGEX_ASSERT(matcher->end(0, status) == matcher->end(status));
REGEX_ASSERT_FAIL(matcher->start(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT_FAIL(matcher->start( 4, status), U_INDEX_OUTOFBOUNDS_ERROR);
matcher->reset();
REGEX_ASSERT_FAIL(matcher->start( 0, status), U_REGEX_INVALID_STATE);
matcher->lookingAt(status);
REGEX_ASSERT(matcher->group(status) == "0123456789");
REGEX_ASSERT(matcher->group(0, status) == "0123456789");
REGEX_ASSERT(matcher->group(1, status) == "234567" );
REGEX_ASSERT(matcher->group(2, status) == "45" );
REGEX_ASSERT(matcher->group(3, status) == "89" );
REGEX_CHECK_STATUS;
REGEX_ASSERT_FAIL(matcher->group(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT_FAIL(matcher->group( 4, status), U_INDEX_OUTOFBOUNDS_ERROR);
matcher->reset();
REGEX_ASSERT_FAIL(matcher->group( 0, status), U_REGEX_INVALID_STATE);
delete matcher;
delete pat;
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
// find
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10050
2002-10-22 00:09:32 +00:00
//
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
UnicodeString re("abc");
RegexPattern *pat = RegexPattern::compile(re, flags, pe, status);
REGEX_CHECK_STATUS;
UnicodeString data = ".abc..abc...abc..";
// 012345678901234567
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
RegexMatcher *matcher = pat->matcher(data, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 6);
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 12);
REGEX_ASSERT(matcher->find() == FALSE);
REGEX_ASSERT(matcher->find() == FALSE);
matcher->reset();
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find(0, status));
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find(1, status));
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find(2, status));
REGEX_ASSERT(matcher->start(status) == 6);
REGEX_ASSERT(matcher->find(12, status));
REGEX_ASSERT(matcher->start(status) == 12);
REGEX_ASSERT(matcher->find(13, status) == FALSE);
REGEX_ASSERT(matcher->find(16, status) == FALSE);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
REGEX_ASSERT(matcher->find(17, status) == FALSE);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
REGEX_ASSERT_FAIL(matcher->start(status), U_REGEX_INVALID_STATE);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
status = U_ZERO_ERROR;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
REGEX_ASSERT_FAIL(matcher->find(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
ICU-4086 regex match/lookingAt/find at end of string with zero length match not working. X-SVN-Rev: 16328
2004-09-15 01:28:15 +00:00
status = U_ZERO_ERROR;
REGEX_ASSERT_FAIL(matcher->find(18, status), U_INDEX_OUTOFBOUNDS_ERROR);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
REGEX_ASSERT(matcher->groupCount() == 0);
delete matcher;
delete pat;
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10063
2002-10-24 22:16:07 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10135
2002-10-31 23:01:54 +00:00
//
// find, with \G in pattern (true if at the end of a previous match).
//
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString re(".*?(?:(\\Gabc)|(abc))", -1, US_INV);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10135
2002-10-31 23:01:54 +00:00
RegexPattern *pat = RegexPattern::compile(re, flags, pe, status);
REGEX_CHECK_STATUS;
UnicodeString data = ".abcabc.abc..";
// 012345678901234567
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10135
2002-10-31 23:01:54 +00:00
RegexMatcher *matcher = pat->matcher(data, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 0);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(matcher->start(1, status) == -1);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10135
2002-10-31 23:01:54 +00:00
REGEX_ASSERT(matcher->start(2, status) == 1);
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 4);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(matcher->start(1, status) == 4);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10135
2002-10-31 23:01:54 +00:00
REGEX_ASSERT(matcher->start(2, status) == -1);
REGEX_CHECK_STATUS;
delete matcher;
delete pat;
}
ICU-2902 regex, matches with no input behave as if input was an empty string Change requested in code review. X-SVN-Rev: 12045
2003-05-22 00:51:23 +00:00
ICU-3436 regex find() now moves start position forward after zero-length matches to avoid loops X-SVN-Rev: 14245
2004-01-07 00:03:46 +00:00
//
// find with zero length matches, match position should bump ahead
// to prevent loops.
//
{
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
int32_t i;
ICU-3436 regex find() now moves start position forward after zero-length matches to avoid loops X-SVN-Rev: 14245
2004-01-07 00:03:46 +00:00
UErrorCode status=U_ZERO_ERROR;
RegexMatcher m("(?= ?)", 0, status); // This pattern will zero-length matches anywhere,
// using an always-true look-ahead.
REGEX_CHECK_STATUS;
UnicodeString s(" ");
m.reset(s);
for (i=0; ; i++) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == i);
}
REGEX_ASSERT(i==5);
// Check that the bump goes over surrogate pairs OK
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
s = UNICODE_STRING_SIMPLE("\\U00010001\\U00010002\\U00010003\\U00010004");
ICU-3436 regex find() now moves start position forward after zero-length matches to avoid loops X-SVN-Rev: 14245
2004-01-07 00:03:46 +00:00
s = s.unescape();
m.reset(s);
for (i=0; ; i+=2) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == i);
}
REGEX_ASSERT(i==10);
}
{
// find() loop breaking test.
// with pattern of /.?/, should see a series of one char matches, then a single
// match of zero length at the end of the input string.
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
int32_t i;
ICU-3436 regex find() now moves start position forward after zero-length matches to avoid loops X-SVN-Rev: 14245
2004-01-07 00:03:46 +00:00
UErrorCode status=U_ZERO_ERROR;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
RegexMatcher m(".?", 0, status);
ICU-3436 regex find() now moves start position forward after zero-length matches to avoid loops X-SVN-Rev: 14245
2004-01-07 00:03:46 +00:00
REGEX_CHECK_STATUS;
UnicodeString s(" ");
m.reset(s);
for (i=0; ; i++) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == (i<4 ? i+1 : i));
}
REGEX_ASSERT(i==5);
}
ICU-2902 regex, matches with no input behave as if input was an empty string Change requested in code review. X-SVN-Rev: 12045
2003-05-22 00:51:23 +00:00
//
// Matchers with no input string behave as if they had an empty input string.
//
{
UErrorCode status = U_ZERO_ERROR;
RegexMatcher m(".?", 0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.find());
REGEX_ASSERT(m.start(status) == 0);
REGEX_ASSERT(m.input() == "");
}
{
UErrorCode status = U_ZERO_ERROR;
RegexPattern *p = RegexPattern::compile(".", 0, status);
RegexMatcher *m = p->matcher(status);
REGEX_CHECK_STATUS;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2902 regex, matches with no input behave as if input was an empty string Change requested in code review. X-SVN-Rev: 12045
2003-05-22 00:51:23 +00:00
REGEX_ASSERT(m->find() == FALSE);
REGEX_ASSERT(m->input() == "");
delete m;
delete p;
}
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
// Regions
//
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString testString("This is test data");
RegexMatcher m(".*", testString, 0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.regionStart() == 0);
REGEX_ASSERT(m.regionEnd() == testString.length());
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
m.region(2,4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.matches(status));
REGEX_ASSERT(m.start(status)==2);
REGEX_ASSERT(m.end(status)==4);
REGEX_CHECK_STATUS;
m.reset();
REGEX_ASSERT(m.regionStart() == 0);
REGEX_ASSERT(m.regionEnd() == testString.length());
UnicodeString shorterString("short");
m.reset(shorterString);
REGEX_ASSERT(m.regionStart() == 0);
REGEX_ASSERT(m.regionEnd() == shorterString.length());
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(&m == &m.useAnchoringBounds(FALSE));
REGEX_ASSERT(m.hasAnchoringBounds() == FALSE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasAnchoringBounds() == FALSE);
REGEX_ASSERT(&m == &m.useAnchoringBounds(TRUE));
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(&m == &m.useTransparentBounds(TRUE));
REGEX_ASSERT(m.hasTransparentBounds() == TRUE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasTransparentBounds() == TRUE);
REGEX_ASSERT(&m == &m.useTransparentBounds(FALSE));
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
}
//
// hitEnd() and requireEnd()
//
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString testString("aabb");
RegexMatcher m1(".*", testString, 0, status);
REGEX_ASSERT(m1.lookingAt(status) == TRUE);
REGEX_ASSERT(m1.hitEnd() == TRUE);
REGEX_ASSERT(m1.requireEnd() == FALSE);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
RegexMatcher m2("a*", testString, 0, status);
REGEX_ASSERT(m2.lookingAt(status) == TRUE);
REGEX_ASSERT(m2.hitEnd() == FALSE);
REGEX_ASSERT(m2.requireEnd() == FALSE);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
RegexMatcher m3(".*$", testString, 0, status);
REGEX_ASSERT(m3.lookingAt(status) == TRUE);
REGEX_ASSERT(m3.hitEnd() == TRUE);
REGEX_ASSERT(m3.requireEnd() == TRUE);
REGEX_CHECK_STATUS;
}
ICU-2902 regex, matches with no input behave as if input was an empty string Change requested in code review. X-SVN-Rev: 12045
2003-05-22 00:51:23 +00:00
ICU-3337 better detect incorrect usage of Regex APIs. X-SVN-Rev: 16595
2004-10-22 16:32:12 +00:00
//
// Compilation error on reset with UChar *
// These were a hazard that people were stumbling over with runtime errors.
// Changed them to compiler errors by adding private methods that more closely
// matched the incorrect use of the functions.
//
#if 0
{
UErrorCode status = U_ZERO_ERROR;
UChar ucharString[20];
RegexMatcher m(".", 0, status);
m.reset(ucharString); // should not compile.
RegexPattern *p = RegexPattern::compile(".", 0, status);
RegexMatcher *m2 = p->matcher(ucharString, status); // should not compile.
RegexMatcher m3(".", ucharString, 0, status); // Should not compile
}
#endif
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
//
// Time Outs.
// Note: These tests will need to be changed when the regexp engine is
// able to detect and cut short the exponential time behavior on
// this type of match.
//
{
UErrorCode status = U_ZERO_ERROR;
// Enough 'a's in the string to cause the match to time out.
// (Each on additonal 'a' doubles the time)
UnicodeString testString("aaaaaaaaaaaaaaaaaaaaa");
RegexMatcher matcher("(a+)+b", testString, 0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher.getTimeLimit() == 0);
matcher.setTimeLimit(100, status);
REGEX_ASSERT(matcher.getTimeLimit() == 100);
REGEX_ASSERT(matcher.lookingAt(status) == FALSE);
REGEX_ASSERT(status == U_REGEX_TIME_OUT);
}
{
UErrorCode status = U_ZERO_ERROR;
// Few enough 'a's to slip in under the time limit.
UnicodeString testString("aaaaaaaaaaaaaaaaaa");
RegexMatcher matcher("(a+)+b", testString, 0, status);
REGEX_CHECK_STATUS;
matcher.setTimeLimit(100, status);
REGEX_ASSERT(matcher.lookingAt(status) == FALSE);
REGEX_CHECK_STATUS;
}
//
// Stack Limits
//
{
UErrorCode status = U_ZERO_ERROR;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UnicodeString testString(1000000, 0x41, 1000000); // Length 1,000,000, filled with 'A'
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
// Adding the capturing parentheses to the pattern "(A)+A$" inhibits optimizations
// of the '+', and makes the stack frames larger.
RegexMatcher matcher("(A)+A$", testString, 0, status);
// With the default stack, this match should fail to run
REGEX_ASSERT(matcher.lookingAt(status) == FALSE);
REGEX_ASSERT(status == U_REGEX_STACK_OVERFLOW);
// With unlimited stack, it should run
status = U_ZERO_ERROR;
matcher.setStackLimit(0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher.lookingAt(status) == TRUE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher.getStackLimit() == 0);
// With a limited stack, it the match should fail
status = U_ZERO_ERROR;
matcher.setStackLimit(10000, status);
REGEX_ASSERT(matcher.lookingAt(status) == FALSE);
REGEX_ASSERT(status == U_REGEX_STACK_OVERFLOW);
REGEX_ASSERT(matcher.getStackLimit() == 10000);
}
// A pattern that doesn't save state should work with
// a minimal sized stack
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString testString = "abc";
RegexMatcher matcher("abc", testString, 0, status);
REGEX_CHECK_STATUS;
matcher.setStackLimit(30, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher.matches(status) == TRUE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher.getStackLimit() == 30);
// Negative stack sizes should fail
status = U_ZERO_ERROR;
matcher.setStackLimit(1000, status);
REGEX_CHECK_STATUS;
matcher.setStackLimit(-1, status);
REGEX_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
REGEX_ASSERT(matcher.getStackLimit() == 1000);
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//---------------------------------------------------------------------------
//
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// API_Replace API test for class RegexMatcher, testing the
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
// Replace family of functions.
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//
//---------------------------------------------------------------------------
void RegexTest::API_Replace() {
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Replace
//
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
UnicodeString re("abc");
RegexPattern *pat = RegexPattern::compile(re, flags, pe, status);
REGEX_CHECK_STATUS;
UnicodeString data = ".abc..abc...abc..";
// 012345678901234567
RegexMatcher *matcher = pat->matcher(data, status);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Plain vanilla matches.
//
UnicodeString dest;
dest = matcher->replaceFirst("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == ".yz..abc...abc..");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceAll("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == ".yz..yz...yz..");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Plain vanilla non-matches.
//
UnicodeString d2 = ".abx..abx...abx..";
matcher->reset(d2);
dest = matcher->replaceFirst("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == ".abx..abx...abx..");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceAll("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == ".abx..abx...abx..");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Empty source string
//
UnicodeString d3 = "";
matcher->reset(d3);
dest = matcher->replaceFirst("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceAll("yz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Empty substitution string
//
matcher->reset(data); // ".abc..abc...abc.."
dest = matcher->replaceFirst("", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "...abc...abc..");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceAll("", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "........");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// match whole string
//
UnicodeString d4 = "abc";
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
matcher->reset(d4);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceFirst("xyz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "xyz");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
dest = matcher->replaceAll("xyz", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "xyz");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
//
// Capture Group, simple case
//
UnicodeString re2("a(..)");
RegexPattern *pat2 = RegexPattern::compile(re2, flags, pe, status);
REGEX_CHECK_STATUS;
UnicodeString d5 = "abcdefg";
RegexMatcher *matcher2 = pat2->matcher(d5, status);
REGEX_CHECK_STATUS;
dest = matcher2->replaceFirst("$1$1", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "bcbcdefg");
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
dest = matcher2->replaceFirst(UNICODE_STRING_SIMPLE("The value of \\$1 is $1."), status);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "The value of $1 is bc.defg");
dest = matcher2->replaceFirst("$ by itself, no group number $$$", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "$ by itself, no group number $$$defg");
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString replacement = UNICODE_STRING_SIMPLE("Supplemental Digit 1 $\\U0001D7CF.");
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
replacement = replacement.unescape();
dest = matcher2->replaceFirst(replacement, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(dest == "Supplemental Digit 1 bc.defg");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10258
2002-11-14 18:27:00 +00:00
REGEX_ASSERT_FAIL(matcher2->replaceFirst("bad capture group number $5...",status), U_INDEX_OUTOFBOUNDS_ERROR);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4030 regexp replacement strings indexing error when containing \uxxxx escapes X-SVN-Rev: 16120
2004-08-06 00:46:28 +00:00
//
// Replacement String with \u hex escapes
//
{
UnicodeString src = "abc 1 abc 2 abc 3";
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString substitute = UNICODE_STRING_SIMPLE("--\\u0043--");
ICU-4030 regexp replacement strings indexing error when containing \uxxxx escapes X-SVN-Rev: 16120
2004-08-06 00:46:28 +00:00
matcher->reset(src);
UnicodeString result = matcher->replaceAll(substitute, status);
REGEX_CHECK_STATUS;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(result == "--C-- 1 --C-- 2 --C-- 3");
ICU-4030 regexp replacement strings indexing error when containing \uxxxx escapes X-SVN-Rev: 16120
2004-08-06 00:46:28 +00:00
}
{
UnicodeString src = "abc !";
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString substitute = UNICODE_STRING_SIMPLE("--\\U00010000--");
ICU-4030 regexp replacement strings indexing error when containing \uxxxx escapes X-SVN-Rev: 16120
2004-08-06 00:46:28 +00:00
matcher->reset(src);
UnicodeString result = matcher->replaceAll(substitute, status);
REGEX_CHECK_STATUS;
UnicodeString expected = UnicodeString("--");
expected.append((UChar32)0x10000);
expected.append("-- !");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
REGEX_ASSERT(result == expected);
ICU-4030 regexp replacement strings indexing error when containing \uxxxx escapes X-SVN-Rev: 16120
2004-08-06 00:46:28 +00:00
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
// TODO: need more through testing of capture substitutions.
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4057 incorrect regex appendReplacement after multiple find()s. X-SVN-Rev: 16601
2004-10-22 22:51:02 +00:00
// Bug 4057
//
{
status = U_ZERO_ERROR;
UnicodeString s = "The matches start with ss and end with ee ss stuff ee fin";
RegexMatcher m("ss(.*?)ee", 0, status);
REGEX_CHECK_STATUS;
UnicodeString result;
// Multiple finds do NOT bump up the previous appendReplacement postion.
m.reset(s);
m.find();
m.find();
m.appendReplacement(result, "ooh", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == "The matches start with ss and end with ee ooh");
// After a reset into the interior of a string, appendReplacemnt still starts at beginning.
status = U_ZERO_ERROR;
result.truncate(0);
m.reset(10, status);
m.find();
m.find();
m.appendReplacement(result, "ooh", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == "The matches start with ss and end with ee ooh");
// find() at interior of string, appendReplacemnt still starts at beginning.
status = U_ZERO_ERROR;
result.truncate(0);
m.reset();
m.find(10, status);
m.find();
m.appendReplacement(result, "ooh", status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == "The matches start with ss and end with ee ooh");
m.appendTail(result);
REGEX_ASSERT(result == "The matches start with ss and end with ee ooh fin");
}
ICU-105 Regular Expressions, memory cleanup X-SVN-Rev: 10186
2002-11-07 20:06:39 +00:00
delete matcher2;
delete pat2;
delete matcher;
delete pat;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
}
//---------------------------------------------------------------------------
//
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10069
2002-10-28 17:18:44 +00:00
// API_Pattern Test that the API for class RegexPattern is
// present and nominally working.
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//
//---------------------------------------------------------------------------
void RegexTest::API_Pattern() {
RegexPattern pata; // Test default constructor to not crash.
RegexPattern patb;
REGEX_ASSERT(pata == patb);
REGEX_ASSERT(pata == pata);
UnicodeString re1("abc[a-l][m-z]");
UnicodeString re2("def");
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
RegexPattern *pat1 = RegexPattern::compile(re1, 0, pe, status);
RegexPattern *pat2 = RegexPattern::compile(re2, 0, pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(*pat1 == *pat1);
REGEX_ASSERT(*pat1 != pata);
// Assign
patb = *pat1;
REGEX_ASSERT(patb == *pat1);
// Copy Construct
RegexPattern patc(*pat1);
REGEX_ASSERT(patc == *pat1);
REGEX_ASSERT(patb == patc);
REGEX_ASSERT(pat1 != pat2);
patb = *pat2;
REGEX_ASSERT(patb != patc);
REGEX_ASSERT(patb == *pat2);
// Compile with no flags.
RegexPattern *pat1a = RegexPattern::compile(re1, pe, status);
REGEX_ASSERT(*pat1a == *pat1);
ICU-0105 API test coverage for RegexPattern::flags() X-SVN-Rev: 10563
2002-12-09 22:43:22 +00:00
REGEX_ASSERT(pat1a->flags() == 0);
ICU-3423 fix problems in RegexPattern assignment/copy/clone X-SVN-Rev: 14255
2004-01-08 00:40:59 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
// Compile with different flags should be not equal
RegexPattern *pat1b = RegexPattern::compile(re1, UREGEX_CASE_INSENSITIVE, pe, status);
REGEX_CHECK_STATUS;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
REGEX_ASSERT(*pat1b != *pat1a);
REGEX_ASSERT(pat1b->flags() == UREGEX_CASE_INSENSITIVE);
REGEX_ASSERT(pat1a->flags() == 0);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
delete pat1b;
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
// clone
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
RegexPattern *pat1c = pat1->clone();
REGEX_ASSERT(*pat1c == *pat1);
REGEX_ASSERT(*pat1c != *pat2);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
delete pat1c;
delete pat1a;
delete pat1;
delete pat2;
ICU-105 Regular Expressions, memory cleanup X-SVN-Rev: 10186
2002-11-07 20:06:39 +00:00
ICU-3423 regex pattern clone test, work in progress. X-SVN-Rev: 14248
2004-01-07 01:24:04 +00:00
//
// Verify that a matcher created from a cloned pattern works.
// (Jitterbug 3423)
//
{
UErrorCode status = U_ZERO_ERROR;
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern *pSource = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\p{L}+"), 0, status);
ICU-3423 regex pattern clone test, work in progress. X-SVN-Rev: 14248
2004-01-07 01:24:04 +00:00
RegexPattern *pClone = pSource->clone();
delete pSource;
RegexMatcher *mFromClone = pClone->matcher(status);
REGEX_CHECK_STATUS;
UnicodeString s = "Hello World";
mFromClone->reset(s);
REGEX_ASSERT(mFromClone->find() == TRUE);
REGEX_ASSERT(mFromClone->group(status) == "Hello");
REGEX_ASSERT(mFromClone->find() == TRUE);
REGEX_ASSERT(mFromClone->group(status) == "World");
REGEX_ASSERT(mFromClone->find() == FALSE);
delete mFromClone;
delete pClone;
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
//
// matches convenience API
//
REGEX_ASSERT(RegexPattern::matches(".*", "random input", pe, status) == TRUE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(RegexPattern::matches("abc", "random input", pe, status) == FALSE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(RegexPattern::matches(".*nput", "random input", pe, status) == TRUE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(RegexPattern::matches("random input", "random input", pe, status) == TRUE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(RegexPattern::matches(".*u", "random input", pe, status) == FALSE);
REGEX_CHECK_STATUS;
status = U_INDEX_OUTOFBOUNDS_ERROR;
REGEX_ASSERT(RegexPattern::matches("abc", "abc", pe, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10053
2002-10-23 16:38:10 +00:00
//
// Split()
//
status = U_ZERO_ERROR;
pat1 = RegexPattern::compile(" +", pe, status);
REGEX_CHECK_STATUS;
UnicodeString fields[10];
int32_t n;
n = pat1->split("Now is the time", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==4);
REGEX_ASSERT(fields[0]=="Now");
REGEX_ASSERT(fields[1]=="is");
REGEX_ASSERT(fields[2]=="the");
REGEX_ASSERT(fields[3]=="time");
REGEX_ASSERT(fields[4]=="");
n = pat1->split("Now is the time", fields, 2, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==2);
REGEX_ASSERT(fields[0]=="Now");
REGEX_ASSERT(fields[1]=="is the time");
REGEX_ASSERT(fields[2]=="the"); // left over from previous test
fields[1] = "*";
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
status = U_ZERO_ERROR;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10053
2002-10-23 16:38:10 +00:00
n = pat1->split("Now is the time", fields, 1, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==1);
REGEX_ASSERT(fields[0]=="Now is the time");
REGEX_ASSERT(fields[1]=="*");
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
status = U_ZERO_ERROR;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10053
2002-10-23 16:38:10 +00:00
n = pat1->split(" Now is the time ", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]=="");
REGEX_ASSERT(fields[1]=="Now");
REGEX_ASSERT(fields[2]=="is");
REGEX_ASSERT(fields[3]=="the");
REGEX_ASSERT(fields[4]=="time");
REGEX_ASSERT(fields[5]=="");
n = pat1->split(" ", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==1);
REGEX_ASSERT(fields[0]=="");
fields[0] = "foo";
n = pat1->split("", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==0);
REGEX_ASSERT(fields[0]=="foo");
ICU-105 Regular Expressions, memory cleanup X-SVN-Rev: 10186
2002-11-07 20:06:39 +00:00
delete pat1;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10053
2002-10-23 16:38:10 +00:00
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
// split, with a pattern with (capture)
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
pat1 = RegexPattern::compile(UNICODE_STRING_SIMPLE("<(\\w*)>"), pe, status);
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
REGEX_CHECK_STATUS;
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
status = U_ZERO_ERROR;
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
n = pat1->split("<a>Now is <b>the time<c>", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]=="");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="");
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
REGEX_ASSERT(status==U_ZERO_ERROR);
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
n = pat1->split(" <a>Now is <b>the time<c>", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="");
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
status = U_ZERO_ERROR;
fields[6] = "foo";
n = pat1->split(" <a>Now is <b>the time<c>", fields, 6, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="foo");
status = U_ZERO_ERROR;
fields[5] = "foo";
n = pat1->split(" <a>Now is <b>the time<c>", fields, 5, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time<c>");
REGEX_ASSERT(fields[5]=="foo");
status = U_ZERO_ERROR;
fields[5] = "foo";
n = pat1->split(" <a>Now is <b>the time", fields, 5, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="foo");
status = U_ZERO_ERROR;
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
n = pat1->split(" <a>Now is <b>the time<c>", fields, 4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==4);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="the time<c>");
ICU-2902 regexp code review changes. X-SVN-Rev: 12066
2003-05-23 01:33:52 +00:00
status = U_ZERO_ERROR;
ICU-105 Regular Expressions, changes from code review X-SVN-Rev: 10294
2002-11-19 19:31:03 +00:00
delete pat1;
pat1 = RegexPattern::compile("([-,])", pe, status);
REGEX_CHECK_STATUS;
n = pat1->split("1-10,20", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]=="1");
REGEX_ASSERT(fields[1]=="-");
REGEX_ASSERT(fields[2]=="10");
REGEX_ASSERT(fields[3]==",");
REGEX_ASSERT(fields[4]=="20");
delete pat1;
ICU-105 Regular Expressions, Add tests for improved API code coverage X-SVN-Rev: 10308
2002-11-21 00:49:52 +00:00
//
// RegexPattern::pattern()
//
pat1 = new RegexPattern();
REGEX_ASSERT(pat1->pattern() == "");
delete pat1;
pat1 = RegexPattern::compile("(Hello, world)*", pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(pat1->pattern() == "(Hello, world)*");
delete pat1;
//
// classID functions
//
pat1 = RegexPattern::compile("(Hello, world)*", pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(pat1->getDynamicClassID() == RegexPattern::getStaticClassID());
REGEX_ASSERT(pat1->getDynamicClassID() != NULL);
ICU-3337 better detect incorrect usage of Regex APIs. X-SVN-Rev: 16595
2004-10-22 16:32:12 +00:00
UnicodeString Hello("Hello, world.");
RegexMatcher *m = pat1->matcher(Hello, status);
ICU-105 Regular Expressions, Add tests for improved API code coverage X-SVN-Rev: 10308
2002-11-21 00:49:52 +00:00
REGEX_ASSERT(pat1->getDynamicClassID() != m->getDynamicClassID());
REGEX_ASSERT(m->getDynamicClassID() == RegexMatcher::getStaticClassID());
REGEX_ASSERT(m->getDynamicClassID() != NULL);
ICU-105 Regular Expressions, fix memory leak, improved test coverage X-SVN-Rev: 10310
2002-11-21 01:06:00 +00:00
delete m;
delete pat1;
ICU-105 Regular Expressions, Add tests for improved API code coverage X-SVN-Rev: 10308
2002-11-21 00:49:52 +00:00
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
}
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//---------------------------------------------------------------------------
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// API_Match_UTF8 Test that the alternate engine for class RegexMatcher
// is present and working, but excluding functions
// implementing replace operations.
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
//---------------------------------------------------------------------------
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
void RegexTest::API_Match_UTF8() {
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
int32_t flags = 0;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Debug - slide failing test cases early
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
#if 0
{
ICU-3389 Don't crash if file can't be found. X-SVN-Rev: 15751
2004-06-07 05:29:50 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
return;
#endif
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Simple pattern compilation
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
UText re = UTEXT_INITIALIZER;
utext_openUTF8(&re, "abc", -1, &status);
RegexPattern *pat2;
pat2 = RegexPattern::compile(&re, flags, pe, status);
REGEX_CHECK_STATUS;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UText input1 = UTEXT_INITIALIZER;
UText input2 = UTEXT_INITIALIZER;
UText empty = UTEXT_INITIALIZER;
utext_openUTF8(&input1, "abcdef this is a test", -1, &status);
utext_openUTF8(&input2, "not abc", -1, &status);
utext_openUChars(&empty, NULL, 0, &status);
int32_t input1Len = strlen("abcdef this is a test");
int32_t input2Len = strlen("not abc");
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Matcher creation and reset.
//
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *m1 = pat2->matcher(&input1, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
REGEX_ASSERT_UTEXT("abcdef this is a test", m1->inputText());
m1->reset(&input2);
REGEX_ASSERT(m1->lookingAt(status) == FALSE);
REGEX_ASSERT_UTEXT("not abc", m1->inputText());
m1->reset(&input1);
REGEX_ASSERT_UTEXT("abcdef this is a test", m1->inputText());
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
m1->reset(&empty);
REGEX_ASSERT(m1->lookingAt(status) == FALSE);
REGEX_ASSERT(utext_nativeLength(&empty) == 0);
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// reset(pos, status)
//
m1->reset(&input1);
m1->reset(4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("abcdef this is a test", m1->inputText());
REGEX_ASSERT(m1->lookingAt(status) == TRUE);
ICU-2422 regexp tests, work in progress. X-SVN-Rev: 10961
2003-02-05 06:50:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
m1->reset(-1, status);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
status = U_ZERO_ERROR;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
m1->reset(0, status);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
m1->reset(input1Len-1, status);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
m1->reset(input1Len, status);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// match(pos, status)
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
m1->reset(&input2);
REGEX_ASSERT(m1->matches(4, status) == TRUE);
m1->reset();
REGEX_ASSERT(m1->matches(3, status) == FALSE);
m1->reset();
REGEX_ASSERT(m1->matches(5, status) == FALSE);
REGEX_ASSERT(m1->matches(4, status) == TRUE);
REGEX_ASSERT(m1->matches(-1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Match() at end of string should fail, but should not
// be an error.
status = U_ZERO_ERROR;
REGEX_ASSERT(m1->matches(input2Len, status) == FALSE);
REGEX_CHECK_STATUS;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Match beyond end of string should fail with an error.
status = U_ZERO_ERROR;
REGEX_ASSERT(m1->matches(input2Len+1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Successful match at end of string.
{
status = U_ZERO_ERROR;
RegexMatcher m("A?", 0, status); // will match zero length string.
REGEX_CHECK_STATUS;
m.reset(&input1);
REGEX_ASSERT(m.matches(input1Len, status) == TRUE);
REGEX_CHECK_STATUS;
m.reset(&empty);
REGEX_ASSERT(m.matches(0, status) == TRUE);
REGEX_CHECK_STATUS;
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
}
ICU-2422 regex test reorg, improved debug options X-SVN-Rev: 10979
2003-02-06 01:55:17 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// lookingAt(pos, status)
ICU-2422 regex test reorg, improved debug options X-SVN-Rev: 10979
2003-02-06 01:55:17 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
status = U_ZERO_ERROR;
m1->reset(&input2); // "not abc"
REGEX_ASSERT(m1->lookingAt(4, status) == TRUE);
REGEX_ASSERT(m1->lookingAt(5, status) == FALSE);
REGEX_ASSERT(m1->lookingAt(3, status) == FALSE);
REGEX_ASSERT(m1->lookingAt(4, status) == TRUE);
REGEX_ASSERT(m1->lookingAt(-1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
REGEX_ASSERT(m1->lookingAt(input2Len, status) == FALSE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m1->lookingAt(input2Len+1, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete m1;
delete pat2;
utext_close(&re);
utext_close(&input1);
utext_close(&input2);
utext_close(&empty);
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Capture Group.
// RegexMatcher::start();
// RegexMatcher::end();
// RegexMatcher::groupCount();
//
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
UText re=UTEXT_INITIALIZER;
utext_openUTF8(&re, "01(23(45)67)(.*)", -1, &status);
RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
REGEX_CHECK_STATUS;
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, "0123456789", -1, &status);
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *matcher = pat->matcher(&input, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher->lookingAt(status) == TRUE);
static const int32_t matchStarts[] = {0, 2, 4, 8};
static const int32_t matchEnds[] = {10, 8, 6, 10};
int32_t i;
for (i=0; i<4; i++) {
int32_t actualStart = matcher->start(i, status);
REGEX_CHECK_STATUS;
if (actualStart != matchStarts[i]) {
errln("RegexTest failure at line %d, index %d. Expected %d, got %d\n",
__LINE__, i, matchStarts[i], actualStart);
}
int32_t actualEnd = matcher->end(i, status);
REGEX_CHECK_STATUS;
if (actualEnd != matchEnds[i]) {
errln("RegexTest failure at line %d index %d. Expected %d, got %d\n",
__LINE__, i, matchEnds[i], actualEnd);
}
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(matcher->start(0, status) == matcher->start(status));
REGEX_ASSERT(matcher->end(0, status) == matcher->end(status));
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT_FAIL(matcher->start(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT_FAIL(matcher->start( 4, status), U_INDEX_OUTOFBOUNDS_ERROR);
matcher->reset();
REGEX_ASSERT_FAIL(matcher->start( 0, status), U_REGEX_INVALID_STATE);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
matcher->lookingAt(status);
UnicodeString dest;
UText destText = UTEXT_INITIALIZER;
utext_openUnicodeString(&destText, &dest, &status);
UText *result;
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
result = matcher->group((UText *)NULL, RegexMatcher::MATCHER_DEST_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("0123456789", result);
utext_close(result);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
result = matcher->group(&destText, RegexMatcher::MATCHER_DEST_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("0123456789", result);
result = matcher->group(0, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("0123456789", result);
utext_close(result);
result = matcher->group(0, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("0123456789", result);
result = matcher->group(1, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("234567", result);
utext_close(result);
result = matcher->group(1, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("234567", result);
result = matcher->group(2, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("45", result);
utext_close(result);
result = matcher->group(2, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("45", result);
result = matcher->group(3, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("89", result);
utext_close(result);
result = matcher->group(3, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("89", result);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT_FAIL(matcher->group(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT_FAIL(matcher->group( 4, status), U_INDEX_OUTOFBOUNDS_ERROR);
matcher->reset();
REGEX_ASSERT_FAIL(matcher->group( 0, status), U_REGEX_INVALID_STATE);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete matcher;
delete pat;
utext_close(&destText);
utext_close(&input);
utext_close(&re);
}
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// find
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
UText re=UTEXT_INITIALIZER;
utext_openUTF8(&re, "abc", -1, &status);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
REGEX_CHECK_STATUS;
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, ".abc..abc...abc..", -1, &status);
// 012345678901234567
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *matcher = pat->matcher(&input, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 6);
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 12);
REGEX_ASSERT(matcher->find() == FALSE);
REGEX_ASSERT(matcher->find() == FALSE);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
matcher->reset();
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 1);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(matcher->find(0, status));
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find(1, status));
REGEX_ASSERT(matcher->start(status) == 1);
REGEX_ASSERT(matcher->find(2, status));
REGEX_ASSERT(matcher->start(status) == 6);
REGEX_ASSERT(matcher->find(12, status));
REGEX_ASSERT(matcher->start(status) == 12);
REGEX_ASSERT(matcher->find(13, status) == FALSE);
REGEX_ASSERT(matcher->find(16, status) == FALSE);
REGEX_ASSERT(matcher->find(17, status) == FALSE);
REGEX_ASSERT_FAIL(matcher->start(status), U_REGEX_INVALID_STATE);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
status = U_ZERO_ERROR;
REGEX_ASSERT_FAIL(matcher->find(-1, status), U_INDEX_OUTOFBOUNDS_ERROR);
status = U_ZERO_ERROR;
REGEX_ASSERT_FAIL(matcher->find(18, status), U_INDEX_OUTOFBOUNDS_ERROR);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(matcher->groupCount() == 0);
delete matcher;
delete pat;
utext_close(&input);
utext_close(&re);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// find, with \G in pattern (true if at the end of a previous match).
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
UText re=UTEXT_INITIALIZER;
utext_openUTF8(&re, ".*?(?:(\\Gabc)|(abc))", -1, &status);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
REGEX_CHECK_STATUS;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, ".abcabc.abc..", -1, &status);
// 012345678901234567
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *matcher = pat->matcher(&input, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 0);
REGEX_ASSERT(matcher->start(1, status) == -1);
REGEX_ASSERT(matcher->start(2, status) == 1);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(matcher->find());
REGEX_ASSERT(matcher->start(status) == 4);
REGEX_ASSERT(matcher->start(1, status) == 4);
REGEX_ASSERT(matcher->start(2, status) == -1);
REGEX_CHECK_STATUS;
delete matcher;
delete pat;
utext_close(&input);
utext_close(&re);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// find with zero length matches, match position should bump ahead
// to prevent loops.
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
int32_t i;
UErrorCode status=U_ZERO_ERROR;
RegexMatcher m("(?= ?)", 0, status); // This pattern will zero-length matches anywhere,
// using an always-true look-ahead.
REGEX_CHECK_STATUS;
UText s = UTEXT_INITIALIZER;
utext_openUTF8(&s, " ", -1, &status);
m.reset(&s);
for (i=0; ; i++) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == i);
}
REGEX_ASSERT(i==5);
// Check that the bump goes over characters outside the BMP OK
// "\\U00010001\\U00010002\\U00010003\\U00010004".unescape()...in UTF-8
unsigned char aboveBMP[] = {0xF0, 0x90, 0x80, 0x81, 0xF0, 0x90, 0x80, 0x82, 0xF0, 0x90, 0x80, 0x83, 0xF0, 0x90, 0x80, 0x84, 0x00};
utext_openUTF8(&s, (char *)aboveBMP, -1, &status);
m.reset(&s);
for (i=0; ; i+=2) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == i);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(i==10);
utext_close(&s);
}
{
// find() loop breaking test.
// with pattern of /.?/, should see a series of one char matches, then a single
// match of zero length at the end of the input string.
int32_t i;
UErrorCode status=U_ZERO_ERROR;
RegexMatcher m(".?", 0, status);
REGEX_CHECK_STATUS;
UText s = UTEXT_INITIALIZER;
utext_openUTF8(&s, " ", -1, &status);
m.reset(&s);
for (i=0; ; i++) {
if (m.find() == FALSE) {
break;
}
REGEX_ASSERT(m.start(status) == i);
REGEX_ASSERT(m.end(status) == (i<4 ? i+1 : i));
}
REGEX_ASSERT(i==5);
utext_close(&s);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Matchers with no input string behave as if they had an empty input string.
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
UErrorCode status = U_ZERO_ERROR;
RegexMatcher m(".?", 0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.find());
REGEX_ASSERT(m.start(status) == 0);
REGEX_ASSERT(m.input() == "");
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
{
UErrorCode status = U_ZERO_ERROR;
RegexPattern *p = RegexPattern::compile(".", 0, status);
RegexMatcher *m = p->matcher(status);
REGEX_CHECK_STATUS;
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(m->find() == FALSE);
REGEX_ASSERT(utext_nativeLength(m->inputText()) == 0);
delete m;
delete p;
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Regions
//
{
UErrorCode status = U_ZERO_ERROR;
UText testPattern = UTEXT_INITIALIZER;
UText testText = UTEXT_INITIALIZER;
utext_openUTF8(&testPattern, ".*", -1, &status);
utext_openUTF8(&testText, "This is test data", -1, &status);
RegexMatcher m(&testPattern, &testText, 0, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.regionStart() == 0);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("This is test data"));
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
m.region(2,4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(m.matches(status));
REGEX_ASSERT(m.start(status)==2);
REGEX_ASSERT(m.end(status)==4);
REGEX_CHECK_STATUS;
m.reset();
REGEX_ASSERT(m.regionStart() == 0);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("This is test data"));
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
utext_openUTF8(&testText, "short", -1, &status);
m.reset(&testText);
REGEX_ASSERT(m.regionStart() == 0);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("short"));
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(&m == &m.useAnchoringBounds(FALSE));
REGEX_ASSERT(m.hasAnchoringBounds() == FALSE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasAnchoringBounds() == FALSE);
REGEX_ASSERT(&m == &m.useAnchoringBounds(TRUE));
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasAnchoringBounds() == TRUE);
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(&m == &m.useTransparentBounds(TRUE));
REGEX_ASSERT(m.hasTransparentBounds() == TRUE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasTransparentBounds() == TRUE);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_ASSERT(&m == &m.useTransparentBounds(FALSE));
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
REGEX_ASSERT(&m == &m.reset());
REGEX_ASSERT(m.hasTransparentBounds() == FALSE);
utext_close(&testText);
utext_close(&testPattern);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// hitEnd() and requireEnd()
//
{
UErrorCode status = U_ZERO_ERROR;
UText testPattern = UTEXT_INITIALIZER;
UText testText = UTEXT_INITIALIZER;
utext_openUTF8(&testPattern, ".*", -1, &status);
utext_openUTF8(&testText, "aabb", -1, &status);
RegexMatcher m1(&testPattern, &testText, 0, status);
REGEX_ASSERT(m1.lookingAt(status) == TRUE);
REGEX_ASSERT(m1.hitEnd() == TRUE);
REGEX_ASSERT(m1.requireEnd() == FALSE);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
utext_openUTF8(&testPattern, "a*", -1, &status);
RegexMatcher m2(&testPattern, &testText, 0, status);
REGEX_ASSERT(m2.lookingAt(status) == TRUE);
REGEX_ASSERT(m2.hitEnd() == FALSE);
REGEX_ASSERT(m2.requireEnd() == FALSE);
REGEX_CHECK_STATUS;
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
status = U_ZERO_ERROR;
utext_openUTF8(&testPattern, ".*$", -1, &status);
RegexMatcher m3(&testPattern, &testText, 0, status);
REGEX_ASSERT(m3.lookingAt(status) == TRUE);
REGEX_ASSERT(m3.hitEnd() == TRUE);
REGEX_ASSERT(m3.requireEnd() == TRUE);
REGEX_CHECK_STATUS;
utext_close(&testText);
utext_close(&testPattern);
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
}
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
//---------------------------------------------------------------------------
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// API_Replace_UTF8 API test for class RegexMatcher, testing the
// Replace family of functions.
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
//
//---------------------------------------------------------------------------
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
void RegexTest::API_Replace_UTF8() {
//
// Replace
//
int32_t flags=0;
UParseError pe;
UErrorCode status=U_ZERO_ERROR;
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10157
2002-11-06 02:35:20 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UText re=UTEXT_INITIALIZER;
utext_openUTF8(&re, "abc", -1, &status);
RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
REGEX_CHECK_STATUS;
char data[] = ".abc..abc...abc..";
// 012345678901234567
UText dataText = UTEXT_INITIALIZER;
utext_openUTF8(&dataText, data, -1, &status);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *matcher = pat->matcher(&dataText, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10180
2002-11-07 02:34:46 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Plain vanilla matches.
//
UnicodeString dest;
UText destText = UTEXT_INITIALIZER;
utext_openUnicodeString(&destText, &dest, &status);
UText *result;
UText replText = UTEXT_INITIALIZER;
utext_openUTF8(&replText, "yz", -1, &status);
result = matcher->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT(".yz..abc...abc..", result);
utext_close(result);
result = matcher->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT(".yz..abc...abc..", result);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10180
2002-11-07 02:34:46 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT(".yz..yz...yz..", result);
utext_close(result);
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT(".yz..yz...yz..", result);
//
// Plain vanilla non-matches.
//
utext_openUTF8(&dataText, ".abx..abx...abx..", -1, &status);
matcher->reset(&dataText);
result = matcher->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT(".abx..abx...abx..", result);
utext_close(result);
result = matcher->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT(".abx..abx...abx..", result);
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT(".abx..abx...abx..", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT(".abx..abx...abx..", result);
//
// Empty source string
//
utext_openUTF8(&dataText, NULL, 0, &status);
matcher->reset(&dataText);
result = matcher->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("", result);
utext_close(result);
result = matcher->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("", result);
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("", result);
utext_close(result);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("", result);
//
// Empty substitution string
//
utext_openUTF8(&dataText, data, -1, &status); // ".abc..abc...abc.."
matcher->reset(&dataText);
utext_openUTF8(&replText, NULL, 0, &status);
result = matcher->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("...abc...abc..", result);
utext_close(result);
result = matcher->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("...abc...abc..", result);
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("........", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("........", result);
//
// match whole string
//
utext_openUTF8(&dataText, "abc", -1, &status);
matcher->reset(&dataText);
utext_openUTF8(&replText, "xyz", -1, &status);
result = matcher->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("xyz", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("xyz", result);
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("xyz", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("xyz", result);
//
// Capture Group, simple case
//
utext_openUTF8(&re, "a(..)", -1, &status);
RegexPattern *pat2 = RegexPattern::compile(&re, flags, pe, status);
REGEX_CHECK_STATUS;
utext_openUTF8(&dataText, "abcdefg", -1, &status);
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *matcher2 = pat2->matcher(&dataText, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS;
utext_openUTF8(&replText, "$1$1", -1, &status);
result = matcher2->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("bcbcdefg", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher2->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("bcbcdefg", result);
utext_openUTF8(&replText, "The value of \\$1 is $1.", -1, &status);
result = matcher2->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("The value of $1 is bc.defg", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher2->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("The value of $1 is bc.defg", result);
utext_openUTF8(&replText, "$ by itself, no group number $$$", -1, &status);
result = matcher2->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("$ by itself, no group number $$$defg", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher2->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("$ by itself, no group number $$$defg", result);
unsigned char supplDigitChars[] = "Supplemental Digit 1 $xxxx."; // \U0001D7CF, MATHEMATICAL BOLD DIGIT ONE
// 012345678901234567890123456
supplDigitChars[22] = 0xF0;
supplDigitChars[23] = 0x9D;
supplDigitChars[24] = 0x9F;
supplDigitChars[25] = 0x8F;
utext_openUTF8(&replText, (char *)supplDigitChars, -1, &status);
result = matcher2->replaceFirst(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("Supplemental Digit 1 bc.defg", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher2->replaceFirst(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("Supplemental Digit 1 bc.defg", result);
utext_openUTF8(&replText, "bad capture group number $5...", -1, &status);
REGEX_ASSERT_FAIL((result = matcher2->replaceFirst(&replText, NULL, status)), U_INDEX_OUTOFBOUNDS_ERROR);
// REGEX_ASSERT_UTEXT("abcdefg", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
REGEX_ASSERT_FAIL((result = matcher2->replaceFirst(&replText, &destText, status)), U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT(result == &destText);
// REGEX_ASSERT_UTEXT("abcdefg", result);
//
// Replacement String with \u hex escapes
//
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
{
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
utext_openUTF8(&dataText, "abc 1 abc 2 abc 3", -1, &status);
utext_openUTF8(&replText, "--\\u0043--", -1, &status);
matcher->reset(&dataText);
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("--C-- 1 --C-- 2 --C-- 3", result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT("--C-- 1 --C-- 2 --C-- 3", result);
}
{
utext_openUTF8(&dataText, "abc !", -1, &status);
utext_openUTF8(&replText, "--\\U00010000--", -1, &status);
matcher->reset(&dataText);
unsigned char expected[] = "--xxxx-- !"; // \U00010000, "LINEAR B SYLLABLE B008 A"
// 0123456789
expected[2] = 0xF0;
expected[3] = 0x90;
expected[4] = 0x80;
expected[5] = 0x80;
result = matcher->replaceAll(&replText, NULL, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT((char *)expected, result);
utext_close(result);
utext_replace(&destText, 0, utext_nativeLength(&destText), NULL, 0, &status);
result = matcher->replaceAll(&replText, &destText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &destText);
REGEX_ASSERT_UTEXT((char *)expected, result);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// TODO: need more through testing of capture substitutions.
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10220
2002-11-11 18:49:49 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Bug 4057
//
{
status = U_ZERO_ERROR;
utext_openUTF8(&re, "ss(.*?)ee", -1, &status);
utext_openUTF8(&dataText, "The matches start with ss and end with ee ss stuff ee fin", -1, &status);
utext_openUTF8(&replText, "ooh", -1, &status);
RegexMatcher m(&re, 0, status);
REGEX_CHECK_STATUS;
UnicodeString result;
UText resultText = UTEXT_INITIALIZER;
utext_openUnicodeString(&resultText, &result, &status);
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10180
2002-11-07 02:34:46 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Multiple finds do NOT bump up the previous appendReplacement postion.
m.reset(&dataText);
m.find();
m.find();
m.appendReplacement(&resultText, &replText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("The matches start with ss and end with ee ooh", &resultText);
ICU-2422 regexp, atomic paretheses added, but still buggy X-SVN-Rev: 10865
2003-01-17 01:43:54 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// After a reset into the interior of a string, appendReplacement still starts at beginning.
status = U_ZERO_ERROR;
result.truncate(0);
utext_openUnicodeString(&resultText, &result, &status);
m.reset(10, status);
m.find();
m.find();
m.appendReplacement(&resultText, &replText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("The matches start with ss and end with ee ooh", &resultText);
// find() at interior of string, appendReplacement still starts at beginning.
status = U_ZERO_ERROR;
result.truncate(0);
utext_openUnicodeString(&resultText, &result, &status);
m.reset();
m.find(10, status);
m.find();
m.appendReplacement(&resultText, &replText, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT_UTEXT("The matches start with ss and end with ee ooh", &resultText);
m.appendTail(&resultText);
REGEX_ASSERT_UTEXT("The matches start with ss and end with ee ooh fin", &resultText);
utext_close(&resultText);
}
delete matcher2;
delete pat2;
delete matcher;
delete pat;
utext_close(&dataText);
utext_close(&replText);
utext_close(&destText);
utext_close(&re);
}
//---------------------------------------------------------------------------
//
// API_Pattern_UTF8 Test that the API for class RegexPattern is
// present and nominally working.
//
//---------------------------------------------------------------------------
void RegexTest::API_Pattern_UTF8() {
RegexPattern pata; // Test default constructor to not crash.
RegexPattern patb;
REGEX_ASSERT(pata == patb);
REGEX_ASSERT(pata == pata);
UText re1 = UTEXT_INITIALIZER;
UText re2 = UTEXT_INITIALIZER;
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
utext_openUTF8(&re1, "abc[a-l][m-z]", -1, &status);
utext_openUTF8(&re2, "def", -1, &status);
RegexPattern *pat1 = RegexPattern::compile(&re1, 0, pe, status);
RegexPattern *pat2 = RegexPattern::compile(&re2, 0, pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(*pat1 == *pat1);
REGEX_ASSERT(*pat1 != pata);
// Assign
patb = *pat1;
REGEX_ASSERT(patb == *pat1);
// Copy Construct
RegexPattern patc(*pat1);
REGEX_ASSERT(patc == *pat1);
REGEX_ASSERT(patb == patc);
REGEX_ASSERT(pat1 != pat2);
patb = *pat2;
REGEX_ASSERT(patb != patc);
REGEX_ASSERT(patb == *pat2);
// Compile with no flags.
RegexPattern *pat1a = RegexPattern::compile(&re1, pe, status);
REGEX_ASSERT(*pat1a == *pat1);
REGEX_ASSERT(pat1a->flags() == 0);
// Compile with different flags should be not equal
RegexPattern *pat1b = RegexPattern::compile(&re1, UREGEX_CASE_INSENSITIVE, pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(*pat1b != *pat1a);
REGEX_ASSERT(pat1b->flags() == UREGEX_CASE_INSENSITIVE);
REGEX_ASSERT(pat1a->flags() == 0);
delete pat1b;
// clone
RegexPattern *pat1c = pat1->clone();
REGEX_ASSERT(*pat1c == *pat1);
REGEX_ASSERT(*pat1c != *pat2);
delete pat1c;
delete pat1a;
delete pat1;
delete pat2;
utext_close(&re1);
utext_close(&re2);
ICU-4037 regexp {min,max} overflow checking cleaned up X-SVN-Rev: 16107
2004-08-04 17:11:55 +00:00
ICU-5389 add test for this regexp error X-SVN-Rev: 21867
2007-06-29 23:40:04 +00:00
ICU-6403 restore original tests for regexp security issues X-SVN-Rev: 24324
2008-06-30 23:53:12 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// Verify that a matcher created from a cloned pattern works.
// (Jitterbug 3423)
//
{
UErrorCode status = U_ZERO_ERROR;
UText pattern = UTEXT_INITIALIZER;
utext_openUTF8(&pattern, "\\p{L}+", -1, &status);
RegexPattern *pSource = RegexPattern::compile(&pattern, 0, status);
RegexPattern *pClone = pSource->clone();
delete pSource;
RegexMatcher *mFromClone = pClone->matcher(status);
REGEX_CHECK_STATUS;
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, "Hello World", -1, &status);
mFromClone->reset(&input);
REGEX_ASSERT(mFromClone->find() == TRUE);
REGEX_ASSERT(mFromClone->group(status) == "Hello");
REGEX_ASSERT(mFromClone->find() == TRUE);
REGEX_ASSERT(mFromClone->group(status) == "World");
REGEX_ASSERT(mFromClone->find() == FALSE);
delete mFromClone;
delete pClone;
utext_close(&input);
utext_close(&pattern);
}
//
// matches convenience API
//
{
UErrorCode status = U_ZERO_ERROR;
UText pattern = UTEXT_INITIALIZER;
UText input = UTEXT_INITIALIZER;
utext_openUTF8(&input, "random input", -1, &status);
utext_openUTF8(&pattern, ".*", -1, &status);
REGEX_ASSERT(RegexPattern::matches(&pattern, &input, pe, status) == TRUE);
REGEX_CHECK_STATUS;
utext_openUTF8(&pattern, "abc", -1, &status);
REGEX_ASSERT(RegexPattern::matches("abc", "random input", pe, status) == FALSE);
REGEX_CHECK_STATUS;
utext_openUTF8(&pattern, ".*nput", -1, &status);
REGEX_ASSERT(RegexPattern::matches(".*nput", "random input", pe, status) == TRUE);
REGEX_CHECK_STATUS;
utext_openUTF8(&pattern, "random input", -1, &status);
REGEX_ASSERT(RegexPattern::matches("random input", "random input", pe, status) == TRUE);
REGEX_CHECK_STATUS;
utext_openUTF8(&pattern, ".*u", -1, &status);
REGEX_ASSERT(RegexPattern::matches(".*u", "random input", pe, status) == FALSE);
REGEX_CHECK_STATUS;
utext_openUTF8(&input, "abc", -1, &status);
utext_openUTF8(&pattern, "abc", -1, &status);
status = U_INDEX_OUTOFBOUNDS_ERROR;
REGEX_ASSERT(RegexPattern::matches("abc", "abc", pe, status) == FALSE);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
utext_close(&input);
utext_close(&pattern);
}
//
// Split()
//
status = U_ZERO_ERROR;
utext_openUTF8(&re1, " +", -1, &status);
pat1 = RegexPattern::compile(&re1, pe, status);
REGEX_CHECK_STATUS;
UnicodeString fields[10];
int32_t n;
n = pat1->split("Now is the time", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==4);
REGEX_ASSERT(fields[0]=="Now");
REGEX_ASSERT(fields[1]=="is");
REGEX_ASSERT(fields[2]=="the");
REGEX_ASSERT(fields[3]=="time");
REGEX_ASSERT(fields[4]=="");
n = pat1->split("Now is the time", fields, 2, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==2);
REGEX_ASSERT(fields[0]=="Now");
REGEX_ASSERT(fields[1]=="is the time");
REGEX_ASSERT(fields[2]=="the"); // left over from previous test
fields[1] = "*";
status = U_ZERO_ERROR;
n = pat1->split("Now is the time", fields, 1, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==1);
REGEX_ASSERT(fields[0]=="Now is the time");
REGEX_ASSERT(fields[1]=="*");
status = U_ZERO_ERROR;
n = pat1->split(" Now is the time ", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]=="");
REGEX_ASSERT(fields[1]=="Now");
REGEX_ASSERT(fields[2]=="is");
REGEX_ASSERT(fields[3]=="the");
REGEX_ASSERT(fields[4]=="time");
REGEX_ASSERT(fields[5]=="");
n = pat1->split(" ", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==1);
REGEX_ASSERT(fields[0]=="");
fields[0] = "foo";
n = pat1->split("", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==0);
REGEX_ASSERT(fields[0]=="foo");
delete pat1;
// split, with a pattern with (capture)
utext_openUTF8(&re1, "<(\\w*)>", -1, &status);
pat1 = RegexPattern::compile(&re1, pe, status);
REGEX_CHECK_STATUS;
status = U_ZERO_ERROR;
n = pat1->split("<a>Now is <b>the time<c>", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]=="");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="");
REGEX_ASSERT(status==U_ZERO_ERROR);
n = pat1->split(" <a>Now is <b>the time<c>", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="");
status = U_ZERO_ERROR;
fields[6] = "foo";
n = pat1->split(" <a>Now is <b>the time<c>", fields, 6, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==6);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="c");
REGEX_ASSERT(fields[6]=="foo");
status = U_ZERO_ERROR;
fields[5] = "foo";
n = pat1->split(" <a>Now is <b>the time<c>", fields, 5, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time<c>");
REGEX_ASSERT(fields[5]=="foo");
status = U_ZERO_ERROR;
fields[5] = "foo";
n = pat1->split(" <a>Now is <b>the time", fields, 5, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="b");
REGEX_ASSERT(fields[4]=="the time");
REGEX_ASSERT(fields[5]=="foo");
status = U_ZERO_ERROR;
n = pat1->split(" <a>Now is <b>the time<c>", fields, 4, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==4);
REGEX_ASSERT(fields[0]==" ");
REGEX_ASSERT(fields[1]=="a");
REGEX_ASSERT(fields[2]=="Now is ");
REGEX_ASSERT(fields[3]=="the time<c>");
status = U_ZERO_ERROR;
delete pat1;
utext_openUTF8(&re1, "([-,])", -1, &status);
pat1 = RegexPattern::compile(&re1, pe, status);
REGEX_CHECK_STATUS;
n = pat1->split("1-10,20", fields, 10, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(n==5);
REGEX_ASSERT(fields[0]=="1");
REGEX_ASSERT(fields[1]=="-");
REGEX_ASSERT(fields[2]=="10");
REGEX_ASSERT(fields[3]==",");
REGEX_ASSERT(fields[4]=="20");
delete pat1;
//
// RegexPattern::pattern() and patternText()
//
pat1 = new RegexPattern();
REGEX_ASSERT(pat1->pattern() == "");
REGEX_ASSERT_UTEXT("", pat1->patternText());
delete pat1;
utext_openUTF8(&re1, "(Hello, world)*", -1, &status);
pat1 = RegexPattern::compile(&re1, pe, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(pat1->pattern() == "(Hello, world)*");
REGEX_ASSERT_UTEXT("(Hello, world)*", pat1->patternText());
delete pat1;
utext_close(&re1);
}
//---------------------------------------------------------------------------
//
// Extended A more thorough check for features of regex patterns
// The test cases are in a separate data file,
// source/tests/testdata/regextst.txt
// A description of the test data format is included in that file.
//
//---------------------------------------------------------------------------
const char *
RegexTest::getPath(char buffer[2048], const char *filename) {
UErrorCode status=U_ZERO_ERROR;
const char *testDataDirectory = IntlTest::getSourceTestData(status);
if (U_FAILURE(status)) {
errln("ERROR: loadTestData() failed - %s", u_errorName(status));
return NULL;
}
strcpy(buffer, testDataDirectory);
strcat(buffer, filename);
return buffer;
}
void RegexTest::Extended() {
char tdd[2048];
const char *srcPath;
UErrorCode status = U_ZERO_ERROR;
int32_t lineNum = 0;
//
// Open and read the test data file.
//
srcPath=getPath(tdd, "regextst.txt");
if(srcPath==NULL) {
return; /* something went wrong, error already output */
}
int32_t len;
UChar *testData = ReadAndConvertFile(srcPath, len, "utf-8", status);
if (U_FAILURE(status)) {
return; /* something went wrong, error already output */
}
//
// Put the test data into a UnicodeString
//
UnicodeString testString(FALSE, testData, len);
RegexMatcher quotedStuffMat(UNICODE_STRING_SIMPLE("\\s*([\\'\\\"/])(.*?)\\1"), 0, status);
RegexMatcher commentMat (UNICODE_STRING_SIMPLE("\\s*(#.*)?$"), 0, status);
RegexMatcher flagsMat (UNICODE_STRING_SIMPLE("\\s*([ixsmdteDEGLMvabtyYzZ2-9]*)([:letter:]*)"), 0, status);
RegexMatcher lineMat(UNICODE_STRING_SIMPLE("(.*?)\\r?\\n"), testString, 0, status);
UnicodeString testPattern; // The pattern for test from the test file.
UnicodeString testFlags; // the flags for a test.
UnicodeString matchString; // The marked up string to be used as input
if (U_FAILURE(status)){
dataerrln("Construct RegexMatcher() error.");
delete [] testData;
return;
}
//
// Loop over the test data file, once per line.
//
while (lineMat.find()) {
lineNum++;
if (U_FAILURE(status)) {
errln("line %d: ICU Error \"%s\"", lineNum, u_errorName(status));
}
status = U_ZERO_ERROR;
UnicodeString testLine = lineMat.group(1, status);
if (testLine.length() == 0) {
continue;
}
//
// Parse the test line. Skip blank and comment only lines.
// Separate out the three main fields - pattern, flags, target.
//
commentMat.reset(testLine);
if (commentMat.lookingAt(status)) {
// This line is a comment, or blank.
continue;
}
//
// Pull out the pattern field, remove it from the test file line.
//
quotedStuffMat.reset(testLine);
if (quotedStuffMat.lookingAt(status)) {
testPattern = quotedStuffMat.group(2, status);
testLine.remove(0, quotedStuffMat.end(0, status));
} else {
errln("Bad pattern (missing quotes?) at test file line %d", lineNum);
continue;
}
//
// Pull out the flags from the test file line.
//
flagsMat.reset(testLine);
flagsMat.lookingAt(status); // Will always match, possibly an empty string.
testFlags = flagsMat.group(1, status);
if (flagsMat.group(2, status).length() > 0) {
errln("Bad Match flag at line %d. Scanning %c\n",
lineNum, flagsMat.group(2, status).charAt(0));
continue;
}
testLine.remove(0, flagsMat.end(0, status));
//
// Pull out the match string, as a whole.
// We'll process the <tags> later.
//
quotedStuffMat.reset(testLine);
if (quotedStuffMat.lookingAt(status)) {
matchString = quotedStuffMat.group(2, status);
testLine.remove(0, quotedStuffMat.end(0, status));
} else {
errln("Bad match string at test file line %d", lineNum);
continue;
}
//
// The only thing left from the input line should be an optional trailing comment.
//
commentMat.reset(testLine);
if (commentMat.lookingAt(status) == FALSE) {
errln("Line %d: unexpected characters at end of test line.", lineNum);
continue;
}
//
// Run the test
//
regex_find(testPattern, testFlags, matchString, lineNum);
}
delete [] testData;
}
//---------------------------------------------------------------------------
//
// regex_find(pattern, flags, inputString, lineNumber)
//
// Function to run a single test from the Extended (data driven) tests.
// See file test/testdata/regextst.txt for a description of the
// pattern and inputString fields, and the allowed flags.
// lineNumber is the source line in regextst.txt of the test.
//
//---------------------------------------------------------------------------
// Set a value into a UVector at position specified by a decimal number in
// a UnicodeString. This is a utility function needed by the actual test function,
// which follows.
static void set(UVector &vec, int32_t val, UnicodeString index) {
UErrorCode status=U_ZERO_ERROR;
int32_t idx = 0;
for (int32_t i=0; i<index.length(); i++) {
int32_t d=u_charDigitValue(index.charAt(i));
if (d<0) {return;}
idx = idx*10 + d;
}
while (vec.size()<idx+1) {vec.addElement(-1, status);}
vec.setElementAt(val, idx);
}
void RegexTest::regex_find(const UnicodeString &pattern,
const UnicodeString &flags,
const UnicodeString &inputString,
int32_t line) {
UnicodeString unEscapedInput;
UnicodeString deTaggedInput;
int32_t patternUTF8Length, inputUTF8Length;
char *patternChars = NULL, *inputChars = NULL;
UText patternText = UTEXT_INITIALIZER;
UText inputText = UTEXT_INITIALIZER;
UConverter *UTF8Converter = NULL;
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
RegexPattern *parsePat = NULL;
RegexMatcher *parseMatcher = NULL;
RegexPattern *callerPattern = NULL, *UTF8Pattern = NULL;
RegexMatcher *matcher = NULL, *UTF8Matcher = NULL;
UVector groupStarts(status);
UVector groupEnds(status);
UBool isMatch = FALSE, isUTF8Match = FALSE;
UBool failed = FALSE;
int32_t numFinds;
int32_t i;
UBool useMatchesFunc = FALSE;
UBool useLookingAtFunc = FALSE;
int32_t regionStart = -1;
int32_t regionEnd = -1;
//
// Compile the caller's pattern
//
uint32_t bflags = 0;
if (flags.indexOf((UChar)0x69) >= 0) { // 'i' flag
bflags |= UREGEX_CASE_INSENSITIVE;
}
if (flags.indexOf((UChar)0x78) >= 0) { // 'x' flag
bflags |= UREGEX_COMMENTS;
}
if (flags.indexOf((UChar)0x73) >= 0) { // 's' flag
bflags |= UREGEX_DOTALL;
}
if (flags.indexOf((UChar)0x6d) >= 0) { // 'm' flag
bflags |= UREGEX_MULTILINE;
}
if (flags.indexOf((UChar)0x65) >= 0) { // 'e' flag
bflags |= UREGEX_ERROR_ON_UNKNOWN_ESCAPES;
}
if (flags.indexOf((UChar)0x44) >= 0) { // 'D' flag
bflags |= UREGEX_UNIX_LINES;
}
callerPattern = RegexPattern::compile(pattern, bflags, pe, status);
if (status != U_ZERO_ERROR) {
#if UCONFIG_NO_BREAK_ITERATION==1
// 'v' test flag means that the test pattern should not compile if ICU was configured
// to not include break iteration. RBBI is needed for Unicode word boundaries.
if (flags.indexOf((UChar)0x76) >= 0 /*'v'*/ && status == U_UNSUPPORTED_ERROR) {
goto cleanupAndReturn;
}
#endif
if (flags.indexOf((UChar)0x45) >= 0) { // flags contain 'E'
// Expected pattern compilation error.
if (flags.indexOf((UChar)0x64) >= 0) { // flags contain 'd'
logln("Pattern Compile returns \"%s\"", u_errorName(status));
}
goto cleanupAndReturn;
} else {
// Unexpected pattern compilation error.
errln("Line %d: error %s compiling pattern.", line, u_errorName(status));
goto cleanupAndReturn;
}
}
UTF8Converter = ucnv_open("UTF8", &status);
ucnv_setFromUCallBack(UTF8Converter, UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status);
patternUTF8Length = pattern.extract(NULL, 0, UTF8Converter, status);
status = U_ZERO_ERROR; // buffer overflow
patternChars = new char[patternUTF8Length+1];
pattern.extract(patternChars, patternUTF8Length+1, UTF8Converter, status);
utext_openUTF8(&patternText, patternChars, patternUTF8Length, &status);
if (status == U_ZERO_ERROR) {
UTF8Pattern = RegexPattern::compile(&patternText, bflags, pe, status);
if (status != U_ZERO_ERROR) {
#if UCONFIG_NO_BREAK_ITERATION==1
// 'v' test flag means that the test pattern should not compile if ICU was configured
// to not include break iteration. RBBI is needed for Unicode word boundaries.
if (flags.indexOf((UChar)0x76) >= 0 /*'v'*/ && status == U_UNSUPPORTED_ERROR) {
goto cleanupAndReturn;
}
#endif
if (flags.indexOf((UChar)0x45) >= 0) { // flags contain 'E'
// Expected pattern compilation error.
if (flags.indexOf((UChar)0x64) >= 0) { // flags contain 'd'
logln("Pattern Compile returns \"%s\" (UTF8)", u_errorName(status));
}
goto cleanupAndReturn;
} else {
// Unexpected pattern compilation error.
errln("Line %d: error %s compiling pattern. (UTF8)", line, u_errorName(status));
goto cleanupAndReturn;
}
}
}
if (UTF8Pattern == NULL) {
// UTF-8 does not allow unpaired surrogates, so this could actually happen without being a failure of the engine
logln("Unable to create UTF-8 pattern, skipping UTF-8 tests for line %d", line);
status = U_ZERO_ERROR;
}
if (flags.indexOf((UChar)0x64) >= 0) { // 'd' flag
RegexPatternDump(callerPattern);
}
if (flags.indexOf((UChar)0x45) >= 0) { // 'E' flag
errln("Expected, but did not get, a pattern compilation error.");
goto cleanupAndReturn;
}
//
// Number of times find() should be called on the test string, default to 1
//
numFinds = 1;
for (i=2; i<=9; i++) {
if (flags.indexOf((UChar)(0x30 + i)) >= 0) { // digit flag
if (numFinds != 1) {
errln("Line %d: more than one digit flag. Scanning %d.", line, i);
goto cleanupAndReturn;
}
numFinds = i;
}
}
// 'M' flag. Use matches() instead of find()
if (flags.indexOf((UChar)0x4d) >= 0) {
useMatchesFunc = TRUE;
}
if (flags.indexOf((UChar)0x4c) >= 0) {
useLookingAtFunc = TRUE;
}
//
// Find the tags in the input data, remove them, and record the group boundary
// positions.
//
parsePat = RegexPattern::compile("<(/?)(r|[0-9]+)>", 0, pe, status);
REGEX_CHECK_STATUS_L(line);
unEscapedInput = inputString.unescape();
parseMatcher = parsePat->matcher(unEscapedInput, status);
REGEX_CHECK_STATUS_L(line);
while(parseMatcher->find()) {
parseMatcher->appendReplacement(deTaggedInput, "", status);
REGEX_CHECK_STATUS;
UnicodeString groupNum = parseMatcher->group(2, status);
if (groupNum == "r") {
// <r> or </r>, a region specification within the string
if (parseMatcher->group(1, status) == "/") {
regionEnd = deTaggedInput.length();
} else {
regionStart = deTaggedInput.length();
}
} else {
// <digits> or </digits>, a group match boundary tag.
if (parseMatcher->group(1, status) == "/") {
set(groupEnds, deTaggedInput.length(), groupNum);
} else {
set(groupStarts, deTaggedInput.length(), groupNum);
}
}
}
parseMatcher->appendTail(deTaggedInput);
REGEX_ASSERT_L(groupStarts.size() == groupEnds.size(), line);
if ((regionStart>=0 || regionEnd>=0) && (regionStart<0 || regionStart>regionEnd)) {
errln("mismatched <r> tags");
failed = TRUE;
goto cleanupAndReturn;
}
//
// Configure the matcher according to the flags specified with this test.
//
matcher = callerPattern->matcher(deTaggedInput, status);
REGEX_CHECK_STATUS_L(line);
if (flags.indexOf((UChar)0x74) >= 0) { // 't' trace flag
matcher->setTrace(TRUE);
}
if (UTF8Pattern != NULL) {
inputUTF8Length = deTaggedInput.extract(NULL, 0, UTF8Converter, status);
status = U_ZERO_ERROR; // buffer overflow
inputChars = new char[inputUTF8Length+1];
deTaggedInput.extract(inputChars, inputUTF8Length+1, UTF8Converter, status);
utext_openUTF8(&inputText, inputChars, inputUTF8Length, &status);
if (status == U_ZERO_ERROR) {
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
UTF8Matcher = UTF8Pattern->matcher(&inputText, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
REGEX_CHECK_STATUS_L(line);
}
if (UTF8Matcher == NULL) {
// UTF-8 does not allow unpaired surrogates, so this could actually happen without being a failure of the engine
logln("Unable to create UTF-8 matcher, skipping UTF-8 tests for line %d", line);
status = U_ZERO_ERROR;
}
}
if (regionStart>=0) {
matcher->region(regionStart, regionEnd, status);
REGEX_CHECK_STATUS_L(line);
if (UTF8Matcher != NULL) {
UTF8Matcher->region(regionStart, regionEnd, status);
REGEX_CHECK_STATUS_L(line);
}
}
if (flags.indexOf((UChar)0x61) >= 0) { // 'a' anchoring bounds flag
matcher->useAnchoringBounds(FALSE);
if (UTF8Matcher != NULL) {
UTF8Matcher->useAnchoringBounds(FALSE);
}
}
if (flags.indexOf((UChar)0x62) >= 0) { // 'b' transparent bounds flag
matcher->useTransparentBounds(TRUE);
if (UTF8Matcher != NULL) {
UTF8Matcher->useTransparentBounds(TRUE);
}
}
//
// Do a find on the de-tagged input using the caller's pattern
// TODO: error on count>1 and not find().
// error on both matches() and lookingAt().
//
for (i=0; i<numFinds; i++) {
if (useMatchesFunc) {
isMatch = matcher->matches(status);
if (UTF8Matcher != NULL) {
isUTF8Match = UTF8Matcher->matches(status);
}
} else if (useLookingAtFunc) {
isMatch = matcher->lookingAt(status);
if (UTF8Matcher != NULL) {
isUTF8Match = UTF8Matcher->lookingAt(status);
}
} else {
isMatch = matcher->find();
if (UTF8Matcher != NULL) {
isUTF8Match = UTF8Matcher->find();
}
}
}
matcher->setTrace(FALSE);
//
// Match up the groups from the find() with the groups from the tags
//
// number of tags should match number of groups from find operation.
// matcher->groupCount does not include group 0, the entire match, hence the +1.
// G option in test means that capture group data is not available in the
// expected results, so the check needs to be suppressed.
if (isMatch == FALSE && groupStarts.size() != 0) {
errln("Error at line %d: Match expected, but none found.", line);
failed = TRUE;
goto cleanupAndReturn;
} else if (UTF8Matcher != NULL && isUTF8Match == FALSE && groupStarts.size() != 0) {
errln("Error at line %d: Match expected, but none found. (UTF8)", line);
failed = TRUE;
goto cleanupAndReturn;
}
if (flags.indexOf((UChar)0x47 /*G*/) >= 0) {
// Only check for match / no match. Don't check capture groups.
if (isMatch && groupStarts.size() == 0) {
errln("Error at line %d: No match expected, but one found.", line);
failed = TRUE;
} else if (UTF8Matcher != NULL && isUTF8Match && groupStarts.size() == 0) {
errln("Error at line %d: No match expected, but one found. (UTF8)", line);
failed = TRUE;
}
goto cleanupAndReturn;
}
REGEX_CHECK_STATUS_L(line);
for (i=0; i<=matcher->groupCount(); i++) {
int32_t expectedStart = (i >= groupStarts.size()? -1 : groupStarts.elementAti(i));
if (matcher->start(i, status) != expectedStart) {
errln("Error at line %d: incorrect start position for group %d. Expected %d, got %d",
line, i, expectedStart, matcher->start(i, status));
failed = TRUE;
goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now.
} else if (UTF8Matcher != NULL && UTF8Matcher->start(i, status) != expectedStart) {
errln("Error at line %d: incorrect start position for group %d. Expected %d, got %d (UTF8)",
line, i, expectedStart, UTF8Matcher->start(i, status));
failed = TRUE;
goto cleanupAndReturn; // Good chance of subsequent bogus errors. Stop now.
}
int32_t expectedEnd = (i >= groupEnds.size()? -1 : groupEnds.elementAti(i));
if (matcher->end(i, status) != expectedEnd) {
errln("Error at line %d: incorrect end position for group %d. Expected %d, got %d",
line, i, expectedEnd, matcher->end(i, status));
failed = TRUE;
// Error on end position; keep going; real error is probably yet to come as group
// end positions work from end of the input data towards the front.
} else if (UTF8Matcher != NULL && UTF8Matcher->end(i, status) != expectedEnd) {
errln("Error at line %d: incorrect end position for group %d. Expected %d, got %d (UTF8)",
line, i, expectedEnd, UTF8Matcher->end(i, status));
failed = TRUE;
// Error on end position; keep going; real error is probably yet to come as group
// end positions work from end of the input data towards the front.
}
}
if ( matcher->groupCount()+1 < groupStarts.size()) {
errln("Error at line %d: Expected %d capture groups, found %d.",
line, groupStarts.size()-1, matcher->groupCount());
failed = TRUE;
}
else if (UTF8Matcher != NULL && UTF8Matcher->groupCount()+1 < groupStarts.size()) {
errln("Error at line %d: Expected %d capture groups, found %d. (UTF8)",
line, groupStarts.size()-1, UTF8Matcher->groupCount());
failed = TRUE;
}
if ((flags.indexOf((UChar)0x59) >= 0) && // 'Y' flag: RequireEnd() == false
matcher->requireEnd() == TRUE) {
errln("Error at line %d: requireEnd() returned TRUE. Expected FALSE", line);
failed = TRUE;
} else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x59) >= 0) && // 'Y' flag: RequireEnd() == false
UTF8Matcher->requireEnd() == TRUE) {
errln("Error at line %d: requireEnd() returned TRUE. Expected FALSE (UTF8)", line);
failed = TRUE;
}
if ((flags.indexOf((UChar)0x79) >= 0) && // 'y' flag: RequireEnd() == true
matcher->requireEnd() == FALSE) {
errln("Error at line %d: requireEnd() returned FALSE. Expected TRUE", line);
failed = TRUE;
} else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x79) >= 0) && // 'Y' flag: RequireEnd() == false
UTF8Matcher->requireEnd() == FALSE) {
errln("Error at line %d: requireEnd() returned FALSE. Expected TRUE (UTF8)", line);
failed = TRUE;
}
if ((flags.indexOf((UChar)0x5A) >= 0) && // 'Z' flag: hitEnd() == false
matcher->hitEnd() == TRUE) {
errln("Error at line %d: hitEnd() returned TRUE. Expected FALSE", line);
failed = TRUE;
} else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x5A) >= 0) && // 'Z' flag: hitEnd() == false
UTF8Matcher->hitEnd() == TRUE) {
errln("Error at line %d: hitEnd() returned TRUE. Expected FALSE (UTF8)", line);
failed = TRUE;
}
if ((flags.indexOf((UChar)0x7A) >= 0) && // 'z' flag: hitEnd() == true
matcher->hitEnd() == FALSE) {
errln("Error at line %d: hitEnd() returned FALSE. Expected TRUE", line);
failed = TRUE;
} else if (UTF8Matcher != NULL && (flags.indexOf((UChar)0x7A) >= 0) && // 'z' flag: hitEnd() == true
UTF8Matcher->hitEnd() == FALSE) {
errln("Error at line %d: hitEnd() returned FALSE. Expected TRUE (UTF8)", line);
failed = TRUE;
}
cleanupAndReturn:
if (failed) {
infoln((UnicodeString)"\""+pattern+(UnicodeString)"\" "
+flags+(UnicodeString)" \""+inputString+(UnicodeString)"\"");
// callerPattern->dump();
}
delete parseMatcher;
delete parsePat;
delete UTF8Matcher;
delete UTF8Pattern;
delete matcher;
delete callerPattern;
utext_close(&inputText);
delete[] inputChars;
utext_close(&patternText);
delete[] patternChars;
ucnv_close(UTF8Converter);
}
//---------------------------------------------------------------------------
//
// Errors Check for error handling in patterns.
//
//---------------------------------------------------------------------------
void RegexTest::Errors() {
// \escape sequences that aren't implemented yet.
//REGEX_ERR("hex format \\x{abcd} not implemented", 1, 13, U_REGEX_UNIMPLEMENTED);
// Missing close parentheses
REGEX_ERR("Comment (?# with no close", 1, 25, U_REGEX_MISMATCHED_PAREN);
REGEX_ERR("Capturing Parenthesis(...", 1, 25, U_REGEX_MISMATCHED_PAREN);
REGEX_ERR("Grouping only parens (?: blah blah", 1, 34, U_REGEX_MISMATCHED_PAREN);
// Extra close paren
REGEX_ERR("Grouping only parens (?: blah)) blah", 1, 31, U_REGEX_MISMATCHED_PAREN);
REGEX_ERR(")))))))", 1, 1, U_REGEX_MISMATCHED_PAREN);
REGEX_ERR("(((((((", 1, 7, U_REGEX_MISMATCHED_PAREN);
// Look-ahead, Look-behind
// TODO: add tests for unbounded length look-behinds.
REGEX_ERR("abc(?<@xyz).*", 1, 7, U_REGEX_RULE_SYNTAX); // illegal construct
// Attempt to use non-default flags
{
UParseError pe;
UErrorCode status = U_ZERO_ERROR;
int32_t flags = UREGEX_CANON_EQ |
UREGEX_COMMENTS | UREGEX_DOTALL |
UREGEX_MULTILINE;
RegexPattern *pat1= RegexPattern::compile(".*", flags, pe, status);
REGEX_ASSERT(status == U_REGEX_UNIMPLEMENTED);
delete pat1;
}
// Quantifiers are allowed only after something that can be quantified.
REGEX_ERR("+", 1, 1, U_REGEX_RULE_SYNTAX);
REGEX_ERR("abc\ndef(*2)", 2, 5, U_REGEX_RULE_SYNTAX);
REGEX_ERR("abc**", 1, 5, U_REGEX_RULE_SYNTAX);
// Mal-formed {min,max} quantifiers
REGEX_ERR("abc{a,2}",1,5, U_REGEX_BAD_INTERVAL);
REGEX_ERR("abc{4,2}",1,8, U_REGEX_MAX_LT_MIN);
REGEX_ERR("abc{1,b}",1,7, U_REGEX_BAD_INTERVAL);
REGEX_ERR("abc{1,,2}",1,7, U_REGEX_BAD_INTERVAL);
REGEX_ERR("abc{1,2a}",1,8, U_REGEX_BAD_INTERVAL);
REGEX_ERR("abc{222222222222222222222}",1,14, U_REGEX_NUMBER_TOO_BIG);
REGEX_ERR("abc{5,50000000000}", 1, 17, U_REGEX_NUMBER_TOO_BIG); // Overflows int during scan
REGEX_ERR("abc{5,687865858}", 1, 16, U_REGEX_NUMBER_TOO_BIG); // Overflows regex binary format
REGEX_ERR("abc{687865858,687865859}", 1, 24, U_REGEX_NUMBER_TOO_BIG);
// Ticket 5389
REGEX_ERR("*c", 1, 1, U_REGEX_RULE_SYNTAX);
// Invalid Back Reference \0
// For ICU 3.8 and earlier
// For ICU versions newer than 3.8, \0 introduces an octal escape.
//
REGEX_ERR("(ab)\\0", 1, 6, U_REGEX_BAD_ESCAPE_SEQUENCE);
}
//-------------------------------------------------------------------------------
//
// Read a text data file, convert it to UChars, and return the data
// in one big UChar * buffer, which the caller must delete.
//
//--------------------------------------------------------------------------------
UChar *RegexTest::ReadAndConvertFile(const char *fileName, int32_t &ulen,
const char *defEncoding, UErrorCode &status) {
UChar *retPtr = NULL;
char *fileBuf = NULL;
UConverter* conv = NULL;
FILE *f = NULL;
ulen = 0;
if (U_FAILURE(status)) {
return retPtr;
}
//
// Open the file.
//
f = fopen(fileName, "rb");
if (f == 0) {
dataerrln("Error opening test data file %s\n", fileName);
status = U_FILE_ACCESS_ERROR;
return NULL;
}
//
// Read it in
//
int32_t fileSize;
int32_t amt_read;
fseek( f, 0, SEEK_END);
fileSize = ftell(f);
fileBuf = new char[fileSize];
fseek(f, 0, SEEK_SET);
amt_read = fread(fileBuf, 1, fileSize, f);
if (amt_read != fileSize || fileSize <= 0) {
errln("Error reading test data file.");
goto cleanUpAndReturn;
}
//
// Look for a Unicode Signature (BOM) on the data just read
//
int32_t signatureLength;
const char * fileBufC;
const char* encoding;
fileBufC = fileBuf;
encoding = ucnv_detectUnicodeSignature(
fileBuf, fileSize, &signatureLength, &status);
if(encoding!=NULL ){
fileBufC += signatureLength;
fileSize -= signatureLength;
} else {
encoding = defEncoding;
if (strcmp(encoding, "utf-8") == 0) {
errln("file %s is missing its BOM", fileName);
}
}
//
// Open a converter to take the rule file to UTF-16
//
conv = ucnv_open(encoding, &status);
if (U_FAILURE(status)) {
goto cleanUpAndReturn;
}
//
// Convert the rules to UChar.
// Preflight first to determine required buffer size.
//
ulen = ucnv_toUChars(conv,
NULL, // dest,
0, // destCapacity,
fileBufC,
fileSize,
&status);
if (status == U_BUFFER_OVERFLOW_ERROR) {
// Buffer Overflow is expected from the preflight operation.
status = U_ZERO_ERROR;
retPtr = new UChar[ulen+1];
ucnv_toUChars(conv,
retPtr, // dest,
ulen+1,
fileBufC,
fileSize,
&status);
}
cleanUpAndReturn:
fclose(f);
delete[] fileBuf;
ucnv_close(conv);
if (U_FAILURE(status)) {
errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status));
delete retPtr;
retPtr = 0;
ulen = 0;
};
return retPtr;
}
//-------------------------------------------------------------------------------
//
// PerlTests - Run Perl's regular expression tests
// The input file for this test is re_tests, the standard regular
// expression test data distributed with the Perl source code.
//
// Here is Perl's description of the test data file:
//
// # The tests are in a separate file 't/op/re_tests'.
// # Each line in that file is a separate test.
// # There are five columns, separated by tabs.
// #
// # Column 1 contains the pattern, optionally enclosed in C<''>.
// # Modifiers can be put after the closing C<'>.
// #
// # Column 2 contains the string to be matched.
// #
// # Column 3 contains the expected result:
// # y expect a match
// # n expect no match
// # c expect an error
// # B test exposes a known bug in Perl, should be skipped
// # b test exposes a known bug in Perl, should be skipped if noamp
// #
// # Columns 4 and 5 are used only if column 3 contains C<y> or C<c>.
// #
// # Column 4 contains a string, usually C<$&>.
// #
// # Column 5 contains the expected result of double-quote
// # interpolating that string after the match, or start of error message.
// #
// # Column 6, if present, contains a reason why the test is skipped.
// # This is printed with "skipped", for harness to pick up.
// #
// # \n in the tests are interpolated, as are variables of the form ${\w+}.
// #
// # If you want to add a regular expression test that can't be expressed
// # in this format, don't add it here: put it in op/pat.t instead.
//
// For ICU, if field 3 contains an 'i', the test will be skipped.
// The test exposes is some known incompatibility between ICU and Perl regexps.
// (The i is in addition to whatever was there before.)
//
//-------------------------------------------------------------------------------
void RegexTest::PerlTests() {
char tdd[2048];
const char *srcPath;
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
//
// Open and read the test data file.
//
srcPath=getPath(tdd, "re_tests.txt");
if(srcPath==NULL) {
return; /* something went wrong, error already output */
}
int32_t len;
UChar *testData = ReadAndConvertFile(srcPath, len, "iso-8859-1", status);
if (U_FAILURE(status)) {
return; /* something went wrong, error already output */
}
//
// Put the test data into a UnicodeString
//
UnicodeString testDataString(FALSE, testData, len);
//
// Regex to break the input file into lines, and strip the new lines.
// One line per match, capture group one is the desired data.
//
RegexPattern* linePat = RegexPattern::compile(UNICODE_STRING_SIMPLE("(.+?)[\\r\\n]+"), 0, pe, status);
if (U_FAILURE(status)) {
dataerrln("RegexPattern::compile() error");
return;
}
RegexMatcher* lineMat = linePat->matcher(testDataString, status);
//
// Regex to split a test file line into fields.
// There are six fields, separated by tabs.
//
RegexPattern* fieldPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\t"), 0, pe, status);
//
// Regex to identify test patterns with flag settings, and to separate them.
// Test patterns with flags look like 'pattern'i
// Test patterns without flags are not quoted: pattern
// Coming out, capture group 2 is the pattern, capture group 3 is the flags.
//
RegexPattern *flagPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("('?)(.*)\\1(.*)"), 0, pe, status);
RegexMatcher* flagMat = flagPat->matcher(status);
//
// The Perl tests reference several perl-isms, which are evaluated/substituted
// in the test data. Not being perl, this must be done explicitly. Here
// are string constants and REs for these constructs.
//
UnicodeString nulnulSrc("${nulnul}");
UnicodeString nulnul("\\u0000\\u0000", -1, US_INV);
nulnul = nulnul.unescape();
UnicodeString ffffSrc("${ffff}");
UnicodeString ffff("\\uffff", -1, US_INV);
ffff = ffff.unescape();
// regexp for $-[0], $+[2], etc.
RegexPattern *groupsPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$([+\\-])\\[(\\d+)\\]"), 0, pe, status);
RegexMatcher *groupsMat = groupsPat->matcher(status);
// regexp for $0, $1, $2, etc.
RegexPattern *cgPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$(\\d+)"), 0, pe, status);
RegexMatcher *cgMat = cgPat->matcher(status);
//
// Main Loop for the Perl Tests, runs once per line from the
// test data file.
//
int32_t lineNum = 0;
int32_t skippedUnimplementedCount = 0;
while (lineMat->find()) {
lineNum++;
//
// Get a line, break it into its fields, do the Perl
// variable substitutions.
//
UnicodeString line = lineMat->group(1, status);
UnicodeString fields[7];
fieldPat->split(line, fields, 7, status);
flagMat->reset(fields[0]);
flagMat->matches(status);
UnicodeString pattern = flagMat->group(2, status);
pattern.findAndReplace("${bang}", "!");
pattern.findAndReplace(nulnulSrc, UNICODE_STRING_SIMPLE("\\u0000\\u0000"));
pattern.findAndReplace(ffffSrc, ffff);
//
// Identify patterns that include match flag settings,
// split off the flags, remove the extra quotes.
//
UnicodeString flagStr = flagMat->group(3, status);
if (U_FAILURE(status)) {
errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status));
return;
}
int32_t flags = 0;
const UChar UChar_c = 0x63; // Char constants for the flag letters.
const UChar UChar_i = 0x69; // (Damn the lack of Unicode support in C)
const UChar UChar_m = 0x6d;
const UChar UChar_x = 0x78;
const UChar UChar_y = 0x79;
if (flagStr.indexOf(UChar_i) != -1) {
flags |= UREGEX_CASE_INSENSITIVE;
}
if (flagStr.indexOf(UChar_m) != -1) {
flags |= UREGEX_MULTILINE;
}
if (flagStr.indexOf(UChar_x) != -1) {
flags |= UREGEX_COMMENTS;
}
//
// Compile the test pattern.
//
status = U_ZERO_ERROR;
RegexPattern *testPat = RegexPattern::compile(pattern, flags, pe, status);
if (status == U_REGEX_UNIMPLEMENTED) {
//
// Test of a feature that is planned for ICU, but not yet implemented.
// skip the test.
skippedUnimplementedCount++;
delete testPat;
status = U_ZERO_ERROR;
continue;
}
if (U_FAILURE(status)) {
// Some tests are supposed to generate errors.
// Only report an error for tests that are supposed to succeed.
if (fields[2].indexOf(UChar_c) == -1 && // Compilation is not supposed to fail AND
fields[2].indexOf(UChar_i) == -1) // it's not an accepted ICU incompatibility
{
errln("line %d: ICU Error \"%s\"\n", lineNum, u_errorName(status));
}
status = U_ZERO_ERROR;
delete testPat;
continue;
}
if (fields[2].indexOf(UChar_i) >= 0) {
// ICU should skip this test.
delete testPat;
continue;
}
if (fields[2].indexOf(UChar_c) >= 0) {
// This pattern should have caused a compilation error, but didn't/
errln("line %d: Expected a pattern compile error, got success.", lineNum);
delete testPat;
continue;
}
//
// replace the Perl variables that appear in some of the
// match data strings.
//
UnicodeString matchString = fields[1];
matchString.findAndReplace(nulnulSrc, nulnul);
matchString.findAndReplace(ffffSrc, ffff);
// Replace any \n in the match string with an actual new-line char.
// Don't do full unescape, as this unescapes more than Perl does, which
// causes other spurious failures in the tests.
matchString.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n");
//
// Run the test, check for expected match/don't match result.
//
RegexMatcher *testMat = testPat->matcher(matchString, status);
UBool found = testMat->find();
UBool expected = FALSE;
if (fields[2].indexOf(UChar_y) >=0) {
expected = TRUE;
}
if (expected != found) {
errln("line %d: Expected %smatch, got %smatch",
lineNum, expected?"":"no ", found?"":"no " );
continue;
}
// Don't try to check expected results if there is no match.
// (Some have stuff in the expected fields)
if (!found) {
delete testMat;
delete testPat;
continue;
}
//
// Interpret the Perl expression from the fourth field of the data file,
// building up an ICU string from the results of the ICU match.
// The Perl expression will contain references to the results of
// a regex match, including the matched string, capture group strings,
// group starting and ending indicies, etc.
//
UnicodeString resultString;
UnicodeString perlExpr = fields[3];
#if SUPPORT_MUTATING_INPUT_STRING
groupsMat->reset(perlExpr);
cgMat->reset(perlExpr);
#endif
while (perlExpr.length() > 0) {
#if !SUPPORT_MUTATING_INPUT_STRING
// Perferred usage. Reset after any modification to input string.
groupsMat->reset(perlExpr);
cgMat->reset(perlExpr);
#endif
if (perlExpr.startsWith("$&")) {
resultString.append(testMat->group(status));
perlExpr.remove(0, 2);
}
else if (groupsMat->lookingAt(status)) {
// $-[0] $+[2] etc.
UnicodeString digitString = groupsMat->group(2, status);
int32_t t = 0;
int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10);
UnicodeString plusOrMinus = groupsMat->group(1, status);
int32_t matchPosition;
if (plusOrMinus.compare("+") == 0) {
matchPosition = testMat->end(groupNum, status);
} else {
matchPosition = testMat->start(groupNum, status);
}
if (matchPosition != -1) {
ICU_Utility::appendNumber(resultString, matchPosition);
}
perlExpr.remove(0, groupsMat->end(status));
}
else if (cgMat->lookingAt(status)) {
// $1, $2, $3, etc.
UnicodeString digitString = cgMat->group(1, status);
int32_t t = 0;
int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10);
if (U_SUCCESS(status)) {
resultString.append(testMat->group(groupNum, status));
status = U_ZERO_ERROR;
}
perlExpr.remove(0, cgMat->end(status));
}
else if (perlExpr.startsWith("@-")) {
int32_t i;
for (i=0; i<=testMat->groupCount(); i++) {
if (i>0) {
resultString.append(" ");
}
ICU_Utility::appendNumber(resultString, testMat->start(i, status));
}
perlExpr.remove(0, 2);
}
else if (perlExpr.startsWith("@+")) {
int32_t i;
for (i=0; i<=testMat->groupCount(); i++) {
if (i>0) {
resultString.append(" ");
}
ICU_Utility::appendNumber(resultString, testMat->end(i, status));
}
perlExpr.remove(0, 2);
}
else if (perlExpr.startsWith(UNICODE_STRING_SIMPLE("\\"))) { // \Escape. Take following char as a literal.
// or as an escaped sequence (e.g. \n)
if (perlExpr.length() > 1) {
perlExpr.remove(0, 1); // Remove the '\', but only if not last char.
}
UChar c = perlExpr.charAt(0);
switch (c) {
case 'n': c = '\n'; break;
// add any other escape sequences that show up in the test expected results.
}
resultString.append(c);
perlExpr.remove(0, 1);
}
else {
// Any characters from the perl expression that we don't explicitly
// recognize before here are assumed to be literals and copied
// as-is to the expected results.
resultString.append(perlExpr.charAt(0));
perlExpr.remove(0, 1);
}
ICU-6403 restore original tests for regexp security issues X-SVN-Rev: 24324
2008-06-30 23:53:12 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (U_FAILURE(status)) {
errln("Line %d: ICU Error \"%s\"", lineNum, u_errorName(status));
break;
}
}
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Expected Results Compare
//
UnicodeString expectedS(fields[4]);
expectedS.findAndReplace(nulnulSrc, nulnul);
expectedS.findAndReplace(ffffSrc, ffff);
expectedS.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n");
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (expectedS.compare(resultString) != 0) {
err("Line %d: Incorrect perl expression results.", lineNum);
infoln((UnicodeString)"Expected \""+expectedS+(UnicodeString)"\"; got \""+resultString+(UnicodeString)"\"");
}
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete testMat;
delete testPat;
ICU-2422 fixed g++ compilation problem in regexcmp, got some other work in progress as well. X-SVN-Rev: 10949
2003-02-04 00:36:30 +00:00
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-2422 fixed g++ compilation problem in regexcmp, got some other work in progress as well. X-SVN-Rev: 10949
2003-02-04 00:36:30 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// All done. Clean up allocated stuff.
ICU-2422 fixed g++ compilation problem in regexcmp, got some other work in progress as well. X-SVN-Rev: 10949
2003-02-04 00:36:30 +00:00
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete cgMat;
delete cgPat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete groupsMat;
delete groupsPat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete flagMat;
delete flagPat;
ICU-5617 Revert encoding detection code for z/OS. X-SVN-Rev: 22057
2007-07-19 16:41:48 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete lineMat;
delete linePat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
delete fieldPat;
delete [] testData;
ICU-5617 Revert encoding detection code for z/OS. X-SVN-Rev: 22057
2007-07-19 16:41:48 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
logln("%d tests skipped because of unimplemented regexp features.", skippedUnimplementedCount);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
}
//-------------------------------------------------------------------------------
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
// PerlTestsUTF8 Run Perl's regular expression tests on UTF-8-based UTexts
// (instead of using UnicodeStrings) to test the alternate engine.
// The input file for this test is re_tests, the standard regular
// expression test data distributed with the Perl source code.
// See PerlTests() for more information.
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
//-------------------------------------------------------------------------------
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
void RegexTest::PerlTestsUTF8() {
ICU-2329 do not use invariant-character conversion for strings with variant characters X-SVN-Rev: 12585
2003-07-02 17:26:20 +00:00
char tdd[2048];
ICU-3500 Fix some compiler warnings X-SVN-Rev: 15643
2004-05-31 02:54:48 +00:00
const char *srcPath;
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
LocalUConverterPointer UTF8Converter(ucnv_open("UTF-8", &status));
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
UText patternText = UTEXT_INITIALIZER;
char *patternChars = NULL;
int32_t patternLength;
int32_t patternCapacity = 0;
UText inputText = UTEXT_INITIALIZER;
char *inputChars = NULL;
int32_t inputLength;
int32_t inputCapacity = 0;
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
ucnv_setFromUCallBack(UTF8Converter.getAlias(), UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Open and read the test data file.
//
ICU-3500 Fix some compiler warnings X-SVN-Rev: 15643
2004-05-31 02:54:48 +00:00
srcPath=getPath(tdd, "re_tests.txt");
if(srcPath==NULL) {
ICU-2329 do not use invariant-character conversion for strings with variant characters X-SVN-Rev: 12585
2003-07-02 17:26:20 +00:00
return; /* something went wrong, error already output */
ICU-2840 tests shouldn't crash if there is no data X-SVN-Rev: 12340
2003-06-06 04:54:34 +00:00
}
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
int32_t len;
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
UChar *testData = ReadAndConvertFile(srcPath, len, "iso-8859-1", status);
ICU-3389 Don't crash if file can't be found. X-SVN-Rev: 15751
2004-06-07 05:29:50 +00:00
if (U_FAILURE(status)) {
return; /* something went wrong, error already output */
}
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Put the test data into a UnicodeString
//
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
UnicodeString testDataString(FALSE, testData, len);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Regex to break the input file into lines, and strip the new lines.
// One line per match, capture group one is the desired data.
//
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern* linePat = RegexPattern::compile(UNICODE_STRING_SIMPLE("(.+?)[\\r\\n]+"), 0, pe, status);
ICU-4354 make intltest pass with no data X-SVN-Rev: 18140
2005-07-05 18:39:00 +00:00
if (U_FAILURE(status)) {
dataerrln("RegexPattern::compile() error");
return;
}
ICU-2422 regex test reorg, work in progress. X-SVN-Rev: 10958
2003-02-05 02:17:32 +00:00
RegexMatcher* lineMat = linePat->matcher(testDataString, status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Regex to split a test file line into fields.
// There are six fields, separated by tabs.
//
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern* fieldPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\t"), 0, pe, status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Regex to identify test patterns with flag settings, and to separate them.
// Test patterns with flags look like 'pattern'i
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
// Test patterns without flags are not quoted: pattern
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
// Coming out, capture group 2 is the pattern, capture group 3 is the flags.
//
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern *flagPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("('?)(.*)\\1(.*)"), 0, pe, status);
ICU-3337 better detect incorrect usage of Regex APIs. X-SVN-Rev: 16595
2004-10-22 16:32:12 +00:00
RegexMatcher* flagMat = flagPat->matcher(status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
// The Perl tests reference several perl-isms, which are evaluated/substituted
// in the test data. Not being perl, this must be done explicitly. Here
// are string constants and REs for these constructs.
ICU-2422 regexp, more fixes to and for the Perl tests. X-SVN-Rev: 10906
2003-01-27 00:33:43 +00:00
//
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
UnicodeString nulnulSrc("${nulnul}");
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString nulnul("\\u0000\\u0000", -1, US_INV);
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
nulnul = nulnul.unescape();
UnicodeString ffffSrc("${ffff}");
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
UnicodeString ffff("\\uffff", -1, US_INV);
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
ffff = ffff.unescape();
// regexp for $-[0], $+[2], etc.
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern *groupsPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$([+\\-])\\[(\\d+)\\]"), 0, pe, status);
ICU-3337 better detect incorrect usage of Regex APIs. X-SVN-Rev: 16595
2004-10-22 16:32:12 +00:00
RegexMatcher *groupsMat = groupsPat->matcher(status);
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
// regexp for $0, $1, $2, etc.
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexPattern *cgPat = RegexPattern::compile(UNICODE_STRING_SIMPLE("\\$(\\d+)"), 0, pe, status);
ICU-3337 better detect incorrect usage of Regex APIs. X-SVN-Rev: 16595
2004-10-22 16:32:12 +00:00
RegexMatcher *cgMat = cgPat->matcher(status);
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
//
// Main Loop for the Perl Tests, runs once per line from the
// test data file.
//
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
int32_t lineNum = 0;
int32_t skippedUnimplementedCount = 0;
while (lineMat->find()) {
lineNum++;
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
//
// Get a line, break it into its fields, do the Perl
// variable substitutions.
//
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
UnicodeString line = lineMat->group(1, status);
UnicodeString fields[7];
fieldPat->split(line, fields, 7, status);
flagMat->reset(fields[0]);
flagMat->matches(status);
UnicodeString pattern = flagMat->group(2, status);
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
pattern.findAndReplace("${bang}", "!");
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
pattern.findAndReplace(nulnulSrc, UNICODE_STRING_SIMPLE("\\u0000\\u0000"));
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
pattern.findAndReplace(ffffSrc, ffff);
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
//
// Identify patterns that include match flag settings,
// split off the flags, remove the extra quotes.
//
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
UnicodeString flagStr = flagMat->group(3, status);
if (U_FAILURE(status)) {
errln("ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status));
return;
}
int32_t flags = 0;
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
const UChar UChar_c = 0x63; // Char constants for the flag letters.
const UChar UChar_i = 0x69; // (Damn the lack of Unicode support in C)
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
const UChar UChar_m = 0x6d;
const UChar UChar_x = 0x78;
const UChar UChar_y = 0x79;
if (flagStr.indexOf(UChar_i) != -1) {
flags |= UREGEX_CASE_INSENSITIVE;
}
if (flagStr.indexOf(UChar_m) != -1) {
flags |= UREGEX_MULTILINE;
}
if (flagStr.indexOf(UChar_x) != -1) {
flags |= UREGEX_COMMENTS;
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Put the pattern in a UTF-8 UText
//
status = U_ZERO_ERROR;
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
patternLength = pattern.extract(patternChars, patternCapacity, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (status == U_BUFFER_OVERFLOW_ERROR) {
status = U_ZERO_ERROR;
delete[] patternChars;
patternCapacity = patternLength + 1;
patternChars = new char[patternCapacity];
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
pattern.extract(patternChars, patternCapacity, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
}
utext_openUTF8(&patternText, patternChars, patternLength, &status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
// Compile the test pattern.
//
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
RegexPattern *testPat = RegexPattern::compile(&patternText, flags, pe, status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
if (status == U_REGEX_UNIMPLEMENTED) {
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
//
// Test of a feature that is planned for ICU, but not yet implemented.
// skip the test.
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
skippedUnimplementedCount++;
delete testPat;
status = U_ZERO_ERROR;
continue;
}
if (U_FAILURE(status)) {
// Some tests are supposed to generate errors.
// Only report an error for tests that are supposed to succeed.
if (fields[2].indexOf(UChar_c) == -1 && // Compilation is not supposed to fail AND
fields[2].indexOf(UChar_i) == -1) // it's not an accepted ICU incompatibility
{
errln("line %d: ICU Error \"%s\"\n", lineNum, u_errorName(status));
}
status = U_ZERO_ERROR;
delete testPat;
continue;
}
if (fields[2].indexOf(UChar_i) >= 0) {
// ICU should skip this test.
delete testPat;
continue;
}
if (fields[2].indexOf(UChar_c) >= 0) {
// This pattern should have caused a compilation error, but didn't/
errln("line %d: Expected a pattern compile error, got success.", lineNum);
delete testPat;
continue;
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-2422 regexp, more fixes to and for the Perl tests. X-SVN-Rev: 10906
2003-01-27 00:33:43 +00:00
//
// replace the Perl variables that appear in some of the
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// match data strings.
ICU-2422 regexp, more fixes to and for the Perl tests. X-SVN-Rev: 10906
2003-01-27 00:33:43 +00:00
//
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
UnicodeString matchString = fields[1];
matchString.findAndReplace(nulnulSrc, nulnul);
matchString.findAndReplace(ffffSrc, ffff);
ICU-2422 regexp, more fixes to and for the Perl tests. X-SVN-Rev: 10906
2003-01-27 00:33:43 +00:00
// Replace any \n in the match string with an actual new-line char.
// Don't do full unescape, as this unescapes more than Perl does, which
// causes other spurious failures in the tests.
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
matchString.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n");
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//
// Put the input in a UTF-8 UText
//
status = U_ZERO_ERROR;
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
inputLength = matchString.extract(inputChars, inputCapacity, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
if (status == U_BUFFER_OVERFLOW_ERROR) {
status = U_ZERO_ERROR;
delete[] inputChars;
inputCapacity = inputLength + 1;
inputChars = new char[inputCapacity];
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
matchString.extract(inputChars, inputCapacity, UTF8Converter.getAlias(), status);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
}
utext_openUTF8(&inputText, inputChars, inputLength, &status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
// Run the test, check for expected match/don't match result.
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
//
ICU-4521 Disambiguate signatures for RegexPattern::matcher,RegexMatcher::group for 0 pointers; fix warnings X-SVN-Rev: 27522
2010-02-09 20:17:52 +00:00
RegexMatcher *testMat = testPat->matcher(&inputText, RegexPattern::PATTERN_IS_UTEXT, status);
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
UBool found = testMat->find();
UBool expected = FALSE;
if (fields[2].indexOf(UChar_y) >=0) {
expected = TRUE;
}
if (expected != found) {
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
errln("line %d: Expected %smatch, got %smatch",
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
lineNum, expected?"":"no ", found?"":"no " );
ICU-2422 regexp, case insensitive matching, work in progress X-SVN-Rev: 11013
2003-02-11 01:17:51 +00:00
continue;
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
}
ICU-5386 Regular Expressions update, improved Java 1.5 compatibility. svn merge -r 22747:23061 from branches/andy/regex X-SVN-Rev: 23063
2007-12-11 21:30:10 +00:00
// Don't try to check expected results if there is no match.
// (Some have stuff in the expected fields)
if (!found) {
delete testMat;
delete testPat;
continue;
}
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
//
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
// Interpret the Perl expression from the fourth field of the data file,
// building up an ICU string from the results of the ICU match.
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
// The Perl expression will contain references to the results of
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
// a regex match, including the matched string, capture group strings,
// group starting and ending indicies, etc.
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
//
UnicodeString resultString;
UnicodeString perlExpr = fields[3];
while (perlExpr.length() > 0) {
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
groupsMat->reset(perlExpr);
cgMat->reset(perlExpr);
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
if (perlExpr.startsWith("$&")) {
resultString.append(testMat->group(status));
perlExpr.remove(0, 2);
}
else if (groupsMat->lookingAt(status)) {
// $-[0] $+[2] etc.
UnicodeString digitString = groupsMat->group(2, status);
int32_t t = 0;
int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10);
UnicodeString plusOrMinus = groupsMat->group(1, status);
int32_t matchPosition;
if (plusOrMinus.compare("+") == 0) {
matchPosition = testMat->end(groupNum, status);
} else {
matchPosition = testMat->start(groupNum, status);
}
if (matchPosition != -1) {
ICU_Utility::appendNumber(resultString, matchPosition);
}
perlExpr.remove(0, groupsMat->end(status));
}
else if (cgMat->lookingAt(status)) {
// $1, $2, $3, etc.
UnicodeString digitString = cgMat->group(1, status);
int32_t t = 0;
int32_t groupNum = ICU_Utility::parseNumber(digitString, t, 10);
if (U_SUCCESS(status)) {
resultString.append(testMat->group(groupNum, status));
status = U_ZERO_ERROR;
}
perlExpr.remove(0, cgMat->end(status));
}
else if (perlExpr.startsWith("@-")) {
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
int32_t i;
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
for (i=0; i<=testMat->groupCount(); i++) {
if (i>0) {
resultString.append(" ");
}
ICU_Utility::appendNumber(resultString, testMat->start(i, status));
}
perlExpr.remove(0, 2);
}
else if (perlExpr.startsWith("@+")) {
ICU-5617 Fix compiler error on Cygwin X-SVN-Rev: 22001
2007-07-16 20:08:07 +00:00
int32_t i;
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
for (i=0; i<=testMat->groupCount(); i++) {
if (i>0) {
resultString.append(" ");
}
ICU_Utility::appendNumber(resultString, testMat->end(i, status));
}
perlExpr.remove(0, 2);
}
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
else if (perlExpr.startsWith(UNICODE_STRING_SIMPLE("\\"))) { // \Escape. Take following char as a literal.
ICU-2422 regexp, match flag setting options added. X-SVN-Rev: 11032
2003-02-12 01:28:01 +00:00
// or as an escaped sequence (e.g. \n)
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
if (perlExpr.length() > 1) {
perlExpr.remove(0, 1); // Remove the '\', but only if not last char.
}
ICU-2422 regexp, match flag setting options added. X-SVN-Rev: 11032
2003-02-12 01:28:01 +00:00
UChar c = perlExpr.charAt(0);
switch (c) {
case 'n': c = '\n'; break;
// add any other escape sequences that show up in the test expected results.
}
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
resultString.append(c);
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
perlExpr.remove(0, 1);
}
else {
// Any characters from the perl expression that we don't explicitly
// recognize before here are assumed to be literals and copied
// as-is to the expected results.
resultString.append(perlExpr.charAt(0));
perlExpr.remove(0, 1);
}
if (U_FAILURE(status)) {
errln("Line %d: ICU Error \"%s\"", lineNum, u_errorName(status));
break;
}
}
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
//
// Expected Results Compare
//
UnicodeString expectedS(fields[4]);
expectedS.findAndReplace(nulnulSrc, nulnul);
expectedS.findAndReplace(ffffSrc, ffff);
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
expectedS.findAndReplace(UNICODE_STRING_SIMPLE("\\n"), "\n");
ICU-2422 regexp, match flag setting options added. X-SVN-Rev: 11032
2003-02-12 01:28:01 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
if (expectedS.compare(resultString) != 0) {
ICU-4092 Remove dead code. Don't use codepage specific CharString. There are other ways to achieve the same results. X-SVN-Rev: 16991
2004-12-22 00:05:59 +00:00
err("Line %d: Incorrect perl expression results.", lineNum);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
infoln((UnicodeString)"Expected \""+expectedS+(UnicodeString)"\"; got \""+resultString+(UnicodeString)"\"");
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
}
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
delete testMat;
delete testPat;
}
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
//
// All done. Clean up allocated stuff.
//
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
delete cgMat;
delete cgPat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
delete groupsMat;
delete groupsPat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
delete flagMat;
delete flagPat;
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
delete lineMat;
delete linePat;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, more perl test fixes. X-SVN-Rev: 10921
2003-01-28 23:44:22 +00:00
delete fieldPat;
ICU-2422 regexp, back out nested capture group hack. The failing test is either a bug or a really odd specification in Perl. Clean up test memory leaks. X-SVN-Rev: 10923
2003-01-29 01:40:59 +00:00
delete [] testData;
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
utext_close(&patternText);
utext_close(&inputText);
delete [] patternChars;
delete [] inputChars;
ICU-4161 remove tabs from source code X-SVN-Rev: 16829
2004-11-11 23:34:58 +00:00
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
logln("%d tests skipped because of unimplemented regexp features.", skippedUnimplementedCount);
}
ICU-6403 restore original tests for regexp security issues X-SVN-Rev: 24324
2008-06-30 23:53:12 +00:00
//--------------------------------------------------------------
//
// Bug6149 Verify limits to heap expansion for backtrack stack.
// Use this pattern,
// "(a?){1,}"
// The zero-length match will repeat forever.
// (That this goes into a loop is another bug)
//
//---------------------------------------------------------------
void RegexTest::Bug6149() {
UnicodeString pattern("(a?){1,}");
UnicodeString s("xyz");
uint32_t flags = 0;
UErrorCode status = U_ZERO_ERROR;
RegexMatcher matcher(pattern, s, flags, status);
UBool result = false;
REGEX_ASSERT_FAIL(result=matcher.matches(status), U_REGEX_STACK_OVERFLOW);
REGEX_ASSERT(result == FALSE);
}
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
//
// Callbacks() Test the callback function.
// When set, callbacks occur periodically during matching operations,
// giving the application code the ability to abort the operation
// before it's normal completion.
//
struct callBackContext {
RegexTest *test;
int32_t maxCalls;
int32_t numCalls;
int32_t lastSteps;
void reset(int32_t max) {maxCalls=max; numCalls=0; lastSteps=0;};
};
U_CDECL_BEGIN
static UBool U_CALLCONV
testCallBackFn(const void *context, int32_t steps) {
callBackContext *info = (callBackContext *)context;
if (info->lastSteps+1 != steps) {
info->test->errln("incorrect steps in callback. Expected %d, got %d\n", info->lastSteps+1, steps);
}
info->lastSteps = steps;
info->numCalls++;
return (info->numCalls < info->maxCalls);
}
U_CDECL_END
void RegexTest::Callbacks() {
{
// Getter returns NULLs if no callback has been set
// The variables that the getter will fill in.
// Init to non-null values so that the action of the getter can be seen.
const void *returnedContext = &returnedContext;
ICU-6149 Use traditional ICU C callback declarations. X-SVN-Rev: 23481
2008-02-25 21:21:47 +00:00
URegexMatchCallback *returnedFn = &testCallBackFn;
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
UErrorCode status = U_ZERO_ERROR;
RegexMatcher matcher("x", 0, status);
REGEX_CHECK_STATUS;
matcher.getMatchCallback(returnedFn, returnedContext, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(returnedFn == NULL);
REGEX_ASSERT(returnedContext == NULL);
}
{
// Set and Get work
callBackContext cbInfo = {this, 0, 0, 0};
const void *returnedContext;
ICU-6149 Use traditional ICU C callback declarations. X-SVN-Rev: 23481
2008-02-25 21:21:47 +00:00
URegexMatchCallback *returnedFn;
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
UErrorCode status = U_ZERO_ERROR;
ICU-6337 Use invariant code page to create UnicodeStrings from string literals that contain "\\". X-SVN-Rev: 24201
2008-06-17 00:55:35 +00:00
RegexMatcher matcher(UNICODE_STRING_SIMPLE("((.)+\\2)+x"), 0, status); // A pattern that can run long.
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
REGEX_CHECK_STATUS;
matcher.setMatchCallback(testCallBackFn, &cbInfo, status);
REGEX_CHECK_STATUS;
matcher.getMatchCallback(returnedFn, returnedContext, status);
REGEX_CHECK_STATUS;
ICU-6149 Use traditional ICU C callback declarations. X-SVN-Rev: 23481
2008-02-25 21:21:47 +00:00
REGEX_ASSERT(returnedFn == testCallBackFn);
ICU-6149 Merge regexp resource limit functions into the trunk X-SVN-Rev: 23467
2008-02-20 03:08:44 +00:00
REGEX_ASSERT(returnedContext == &cbInfo);
// A short-running match shouldn't invoke the callback
status = U_ZERO_ERROR;
cbInfo.reset(1);
UnicodeString s = "xxx";
matcher.reset(s);
REGEX_ASSERT(matcher.matches(status));
REGEX_CHECK_STATUS;
REGEX_ASSERT(cbInfo.numCalls == 0);
// A medium-length match that runs long enough to invoke the
// callback, but not so long that the callback aborts it.
status = U_ZERO_ERROR;
cbInfo.reset(4);
s = "aaaaaaaaaaaaaaaaaaab";
matcher.reset(s);
REGEX_ASSERT(matcher.matches(status)==FALSE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(cbInfo.numCalls > 0);
// A longer running match that the callback function will abort.
status = U_ZERO_ERROR;
cbInfo.reset(4);
s = "aaaaaaaaaaaaaaaaaaaaaaab";
matcher.reset(s);
REGEX_ASSERT(matcher.matches(status)==FALSE);
REGEX_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
REGEX_ASSERT(cbInfo.numCalls == 4);
}
}
ICU-2422 regexp, tests from perl, and some bug fixes X-SVN-Rev: 10901
2003-01-24 02:05:03 +00:00
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
//
// FindProgressCallbacks() Test the find "progress" callback function.
// When set, the find progress callback will be invoked during a find operations
// after each return from a match attempt, giving the application the opportunity
// to terminate a long-running find operation before it's normal completion.
//
struct progressCallBackContext {
RegexTest *test;
int64_t lastIndex;
int32_t maxCalls;
int32_t numCalls;
void reset(int32_t max) {maxCalls=max; numCalls=0;lastIndex=0;};
};
U_CDECL_BEGIN
static UBool U_CALLCONV
testProgressCallBackFn(const void *context, int64_t matchIndex) {
progressCallBackContext *info = (progressCallBackContext *)context;
info->numCalls++;
info->lastIndex = matchIndex;
// info->test->infoln("ProgressCallback - matchIndex = %d, numCalls = %d\n", matchIndex, info->numCalls);
return (info->numCalls < info->maxCalls);
}
U_CDECL_END
void RegexTest::FindProgressCallbacks() {
{
// Getter returns NULLs if no callback has been set
// The variables that the getter will fill in.
// Init to non-null values so that the action of the getter can be seen.
const void *returnedContext = &returnedContext;
URegexFindProgressCallback *returnedFn = &testProgressCallBackFn;
UErrorCode status = U_ZERO_ERROR;
RegexMatcher matcher("x", 0, status);
REGEX_CHECK_STATUS;
matcher.getFindProgressCallback(returnedFn, returnedContext, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(returnedFn == NULL);
REGEX_ASSERT(returnedContext == NULL);
}
{
// Set and Get work
progressCallBackContext cbInfo = {this, 0, 0, 0};
const void *returnedContext;
URegexFindProgressCallback *returnedFn;
UErrorCode status = U_ZERO_ERROR;
RegexMatcher matcher(UNICODE_STRING_SIMPLE("((.)+\\2)+x"), 0, status); // A pattern that can run long.
REGEX_CHECK_STATUS;
matcher.setFindProgressCallback(testProgressCallBackFn, &cbInfo, status);
REGEX_CHECK_STATUS;
matcher.getFindProgressCallback(returnedFn, returnedContext, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(returnedFn == testProgressCallBackFn);
REGEX_ASSERT(returnedContext == &cbInfo);
// A short-running match should NOT invoke the callback.
status = U_ZERO_ERROR;
cbInfo.reset(100);
UnicodeString s = "abxxx";
matcher.reset(s);
#if 0
matcher.setTrace(TRUE);
#endif
REGEX_ASSERT(matcher.find(0, status));
REGEX_CHECK_STATUS;
REGEX_ASSERT(cbInfo.numCalls == 0);
// A medium running match that causes matcher.find() to invoke our callback for each index.
status = U_ZERO_ERROR;
s = "aaaaaaaaaaaaaaaaaaab";
cbInfo.reset(s.length()); // Some upper limit for number of calls that is greater than size of our input string
matcher.reset(s);
REGEX_ASSERT(matcher.find(0, status)==FALSE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(cbInfo.numCalls > 0 && cbInfo.numCalls < 25);
// A longer running match that causes matcher.find() to invoke our callback which we cancel/interrupt at some point.
status = U_ZERO_ERROR;
UnicodeString s1 = "aaaaaaaaaaaaaaaaaaaaaaab";
cbInfo.reset(s1.length() - 5); // Bail early somewhere near the end of input string
matcher.reset(s1);
REGEX_ASSERT(matcher.find(0, status)==FALSE);
REGEX_CHECK_STATUS;
REGEX_ASSERT(cbInfo.numCalls == s1.length() - 5);
#if 0
// Now a match that will succeed, but after an interruption
status = U_ZERO_ERROR;
UnicodeString s2 = "aaaaaaaaaaaaaa aaaaaaaaab xxx";
cbInfo.reset(s2.length() - 10); // Bail early somewhere near the end of input string
matcher.reset(s2);
REGEX_ASSERT(matcher.find(0, status)==FALSE);
REGEX_CHECK_STATUS;
// Now retry the match from where left off
cbInfo.maxCalls = 100; // No callback limit
REGEX_ASSERT(matcher.find(cbInfo.lastIndex, status));
REGEX_CHECK_STATUS;
#endif
}
}
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
//---------------------------------------------------------------------------
//
// PreAllocatedUTextCAPI Check the C API with pre-allocated mutable
// UTexts. The pure-C implementation of UText
// has no mutable backing stores, but we can
// use UnicodeString here to test the functionality.
//
//---------------------------------------------------------------------------
void RegexTest::PreAllocatedUTextCAPI () {
UErrorCode status = U_ZERO_ERROR;
URegularExpression *re;
UText patternText = UTEXT_INITIALIZER;
UnicodeString buffer;
UText bufferText = UTEXT_INITIALIZER;
utext_openUnicodeString(&bufferText, &buffer, &status);
/*
* getText() and getUText()
*/
{
UText text1 = UTEXT_INITIALIZER;
UText text2 = UTEXT_INITIALIZER;
UChar text2Chars[20];
UText *resultText;
status = U_ZERO_ERROR;
utext_openUTF8(&text1, "abcccd", -1, &status);
utext_openUTF8(&text2, "abcccxd", -1, &status);
u_uastrncpy(text2Chars, "abcccxd", sizeof(text2)/2);
utext_openUChars(&text2, text2Chars, -1, &status);
utext_openUTF8(&patternText, "abc*d", -1, &status);
re = uregex_openUText(&patternText, 0, NULL, &status);
/* First set a UText */
uregex_setUText(re, &text1, &status);
resultText = uregex_getUText(re, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(resultText == &bufferText);
utext_setNativeIndex(resultText, 0);
utext_setNativeIndex(&text1, 0);
REGEX_ASSERT(utext_compare(resultText, -1, &text1, -1) == 0);
resultText = uregex_getUText(re, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(resultText == &bufferText);
utext_setNativeIndex(resultText, 0);
utext_setNativeIndex(&text1, 0);
REGEX_ASSERT(utext_compare(resultText, -1, &text1, -1) == 0);
/* Then set a UChar * */
uregex_setText(re, text2Chars, 7, &status);
resultText = uregex_getUText(re, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(resultText == &bufferText);
utext_setNativeIndex(resultText, 0);
utext_setNativeIndex(&text2, 0);
REGEX_ASSERT(utext_compare(resultText, -1, &text2, -1) == 0);
uregex_close(re);
utext_close(&text1);
utext_close(&text2);
}
/*
* group()
*/
{
UChar text1[80];
UText *actual;
UBool result;
u_uastrncpy(text1, "noise abc interior def, and this is off the end", sizeof(text1)/2);
status = U_ZERO_ERROR;
re = uregex_openC("abc(.*?)def", 0, NULL, &status);
REGEX_CHECK_STATUS;
uregex_setText(re, text1, -1, &status);
result = uregex_find(re, 0, &status);
REGEX_ASSERT(result==TRUE);
/* Capture Group 0, the full match. Should succeed. */
status = U_ZERO_ERROR;
actual = uregex_groupUText(re, 0, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(actual == &bufferText);
REGEX_ASSERT_UTEXT("abc interior def", actual);
/* Capture group #1. Should succeed. */
status = U_ZERO_ERROR;
actual = uregex_groupUText(re, 1, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(actual == &bufferText);
REGEX_ASSERT_UTEXT(" interior ", actual);
/* Capture group out of range. Error. */
status = U_ZERO_ERROR;
actual = uregex_groupUText(re, 2, &bufferText, &status);
REGEX_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
REGEX_ASSERT(actual == &bufferText);
uregex_close(re);
}
/*
* replaceFirst()
*/
{
UChar text1[80];
UChar text2[80];
UText replText = UTEXT_INITIALIZER;
UText *result;
status = U_ZERO_ERROR;
u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
utext_openUTF8(&replText, "<$1>", -1, &status);
re = uregex_openC("x(.*?)x", 0, NULL, &status);
REGEX_CHECK_STATUS;
/* Normal case, with match */
uregex_setText(re, text1, -1, &status);
utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status);
result = uregex_replaceFirstUText(re, &replText, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &bufferText);
REGEX_ASSERT_UTEXT("Replace <aa> x1x x...x.", result);
/* No match. Text should copy to output with no changes. */
uregex_setText(re, text2, -1, &status);
utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status);
result = uregex_replaceFirstUText(re, &replText, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &bufferText);
REGEX_ASSERT_UTEXT("No match here.", result);
/* Unicode escapes */
uregex_setText(re, text1, -1, &status);
utext_openUTF8(&replText, "\\\\\\u0041$1\\U00000042$\\a", -1, &status);
utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status);
result = uregex_replaceFirstUText(re, &replText, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &bufferText);
REGEX_ASSERT_UTEXT("Replace \\AaaB$a x1x x...x.", result);
uregex_close(re);
utext_close(&replText);
}
/*
* replaceAll()
*/
{
UChar text1[80];
UChar text2[80];
UText replText = UTEXT_INITIALIZER;
UText *result;
status = U_ZERO_ERROR;
u_uastrncpy(text1, "Replace xaax x1x x...x.", sizeof(text1)/2);
u_uastrncpy(text2, "No match here.", sizeof(text2)/2);
utext_openUTF8(&replText, "<$1>", -1, &status);
re = uregex_openC("x(.*?)x", 0, NULL, &status);
REGEX_CHECK_STATUS;
/* Normal case, with match */
uregex_setText(re, text1, -1, &status);
utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status);
result = uregex_replaceAllUText(re, &replText, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &bufferText);
REGEX_ASSERT_UTEXT("Replace <aa> <1> <...>.", result);
/* No match. Text should copy to output with no changes. */
uregex_setText(re, text2, -1, &status);
utext_replace(&bufferText, 0, utext_nativeLength(&bufferText), NULL, 0, &status);
result = uregex_replaceAllUText(re, &replText, &bufferText, &status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(result == &bufferText);
REGEX_ASSERT_UTEXT("No match here.", result);
uregex_close(re);
utext_close(&replText);
}
/*
* splitUText() uses the C++ API directly, and the UnicodeString version uses mutable UTexts,
* so we don't need to test it here.
*/
utext_close(&bufferText);
ICU-7541 fix memory leaks in intltest regex X-SVN-Rev: 27826
2010-03-11 23:43:03 +00:00
utext_close(&patternText);
ICU-4521 UText-based regex implementation X-SVN-Rev: 27482
2010-02-03 02:59:35 +00:00
}
ICU-7651 Add test case (segfaults without the fix in r27992) X-SVN-Rev: 27994
2010-04-28 03:55:58 +00:00
//--------------------------------------------------------------
//
// Bug7651 Regex pattern that exceeds default operator stack depth in matcher.
//
//---------------------------------------------------------------
void RegexTest::Bug7651() {
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]+)");
// The following should exceed the default operator stack depth in the matcher, i.e. force the matcher to malloc instead of using fSmallData.
ICU-7666 Regex find progress callback (from branch to trunk) X-SVN-Rev: 28201
2010-06-15 20:19:10 +00:00
// 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.
ICU-7651 Add test case (segfaults without the fix in r27992) X-SVN-Rev: 27994
2010-04-28 03:55:58 +00:00
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]+)");
UnicodeString s("#ff @abcd This is test");
RegexPattern *REPattern = NULL;
RegexMatcher *REMatcher = NULL;
UErrorCode status = U_ZERO_ERROR;
UParseError pe;
REPattern = RegexPattern::compile(pattern1, 0, pe, status);
REGEX_CHECK_STATUS;
REMatcher = REPattern->matcher(s, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(REMatcher->find());
REGEX_ASSERT(REMatcher->start(status) == 0);
delete REPattern;
delete REMatcher;
status = U_ZERO_ERROR;
REPattern = RegexPattern::compile(pattern2, 0, pe, status);
REGEX_CHECK_STATUS;
REMatcher = REPattern->matcher(s, status);
REGEX_CHECK_STATUS;
REGEX_ASSERT(REMatcher->find());
REGEX_ASSERT(REMatcher->start(status) == 0);
delete REPattern;
delete REMatcher;
status = U_ZERO_ERROR;
}
ICU-105 Regular Expressions, ongoing development X-SVN-Rev: 10180
2002-11-07 02:34:46 +00:00
#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
ICU-105 Regular Expressions initial check in X-SVN-Rev: 10051
2002-10-23 01:14:17 +00:00
Reference in New Issue Copy Permalink