Update ICU to 54.1 step 1

source/test/intltest/regextst.cpp

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 2002-2013, International Business Machines Corporation and
+ * Copyright (c) 2002-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 //
 //   regextst.cpp
 //
 //      ICU Regular Expressions test, part of intltest.
 //
 
 /*
      NOTE!!
 
      PLEASE be careful about ASCII assumptions in this test.
      This test is one of the worst repeat offenders.
      If you have questions, contact someone on the ICU PMC
      who has access to an EBCDIC system.
 
  */
 
 #include "intltest.h"
 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 
+#include "unicode/localpointer.h"
 #include "unicode/regex.h"
 #include "unicode/uchar.h"
 #include "unicode/ucnv.h"
 #include "unicode/uniset.h"
+#include "unicode/uregex.h"
+#include "unicode/usetiter.h"
 #include "unicode/ustring.h"
 #include "regextst.h"
+#include "regexcmp.h"
 #include "uvector.h"
 #include "util.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include "cstring.h"
 #include "uinvchar.h"
 
 #define SUPPORT_MUTATING_INPUT_STRING   0
 
@@ skipping 82 matching lines @@
             break;
         case 19: name = "Bug 7029";
             if (exec) Bug7029();
             break;
         case 20: name = "CheckInvBufSize";
             if (exec) CheckInvBufSize();
             break;
         case 21: name = "Bug 9283";
             if (exec) Bug9283();
             break;
-        case 22: name = "TestBug11371";
-            if (exec) TestBug11371();
+        case 22: name = "Bug10459";
+            if (exec) Bug10459();
             break;
-
+        case 23: name = "TestCaseInsensitiveStarters";
+            if (exec) TestCaseInsensitiveStarters();
+            break;
+        case 24: name = "TestBug11049";
+            if (exec) TestBug11049();
+            break;
         default: name = "";
             break; //needed to end loop
     }
 }
 
 
 
 /**
  * Calls utext_openUTF8 after, potentially, converting invariant text from the compilation codepage
- * into ASCII. 
+ * into ASCII.
  * @see utext_openUTF8
  */
 static UText* regextst_openUTF8FromInvariant(UText* ut, const char *inv, int64_t length, UErrorCode *status);
 
 //---------------------------------------------------------------------------
 //
 //   Error Checking / Reporting macros used in all of the tests.
 //
 //---------------------------------------------------------------------------
 
@@ skipping 45 matching lines @@
           UChar ch = buf[i];
           sprintf(ASSERT_BUF+strlen(ASSERT_BUF),"\\u%02x",ch);
         }
       }
     }
   }
   ASSERT_BUF[sizeof(ASSERT_BUF)-1] = 0;
   return ASSERT_BUF;
 }
 
-
 #define REGEX_VERBOSE_TEXT(text) {char buf[200];utextToPrintable(buf,sizeof(buf)/sizeof(buf[0]),text);logln("%s:%d: UText %s=\"%s\"", __FILE__, __LINE__, #text, buf);}
 
 #define REGEX_CHECK_STATUS {if (U_FAILURE(status)) {dataerrln("%s:%d: RegexTest failure.  status=%s", \
                                                               __FILE__, __LINE__, u_errorName(status)); return;}}
 
 #define REGEX_ASSERT(expr) {if ((expr)==FALSE) {errln("%s:%d: RegexTest failure: REGEX_ASSERT(%s) failed \n", __FILE__, __LINE__, #expr);};}
 
 #define REGEX_ASSERT_FAIL(expr, errcode) {UErrorCode status=U_ZERO_ERROR; (expr);\
 if (status!=errcode) {dataerrln("RegexTest failure at line %d.  Expected status=%s, got %s", \
     __LINE__, u_errorName(errcode), u_errorName(status));};}
@@ skipping 65 matching lines @@
         char buf[201 /*21*/];
         char expectedBuf[201];
         utextToPrintable(buf, sizeof(buf)/sizeof(buf[0]), actual);
         utextToPrintable(expectedBuf, sizeof(expectedBuf)/sizeof(expectedBuf[0]), &expectedText);
         errln("%s:%d: assertUTextInvariant: Failure: expected \"%s\" (%d uchars), got \"%s\" (%d chars)", file, line, expectedBuf, (int)utext_nativeLength(&expectedText), buf, (int)utext_nativeLength(actual));
     }
     utext_close(&expectedText);
 }
 
 /**
- * Assumes utf-8 input 
+ * Assumes utf-8 input
  */
 #define REGEX_ASSERT_UTEXT_UTF8(expected, actual) assertUText((expected), (actual), __FILE__, __LINE__)
 /**
- * Assumes Invariant input 
+ * Assumes Invariant input
  */
 #define REGEX_ASSERT_UTEXT_INVARIANT(expected, actual) assertUTextInvariant((expected), (actual), __FILE__, __LINE__)
 
 /**
  * This buffer ( inv_buf ) is used to hold the UTF-8 strings
  * passed into utext_openUTF8. An error will be given if
  * INV_BUFSIZ is too small.  It's only used on EBCDIC systems.
- */ 
+ */
 
 #define INV_BUFSIZ 2048 /* increase this if too small */
 
 static int64_t inv_next=0;
 
 #if U_CHARSET_FAMILY!=U_ASCII_FAMILY
 static char inv_buf[INV_BUFSIZ];
 #endif
 
 static UText* regextst_openUTF8FromInvariant(UText *ut, const char *inv, int64_t length, UErrorCode *status) {
@@ skipping 47 matching lines @@
     RegexMatcher        *REMatcher = NULL;
     UBool               retVal     = TRUE;
 
     UnicodeString patString(pat, -1, US_INV);
     REPattern = RegexPattern::compile(patString, 0, pe, status);
     if (U_FAILURE(status)) {
         dataerrln("RegexTest failure in RegexPattern::compile() at line %d.  Status = %s",
             line, u_errorName(status));
         return FALSE;
     }
-    if (line==376) { RegexPatternDump(REPattern);}
+    if (line==376) { REPattern->dumpPattern();}
 
     UnicodeString inputString(inputText);
     UnicodeString unEscapedInput = inputString.unescape();
     REMatcher = REPattern->matcher(unEscapedInput, status);
     if (U_FAILURE(status)) {
         errln("RegexTest failure in REPattern::matcher() at line %d.  Status = %s\n",
             line, u_errorName(status));
         return FALSE;
     }
 
@@ skipping 15 matching lines @@
         errln("RegexTest failure in matches() at line %d.  Status = %s\n",
             line, u_errorName(status));
         retVal = FALSE;
     }
     if (actualmatch != match) {
         errln("RegexTest: wrong return from matches() at line %d.\n", line);
         retVal = FALSE;
     }
 
     if (retVal == FALSE) {
-        RegexPatternDump(REPattern);
+        REPattern->dumpPattern();
     }
 
     delete REPattern;
     delete REMatcher;
     return retVal;
 }
 
 
 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;
 
     regextst_openUTF8FromInvariant(&pattern, pat, -1, &status);
     REPattern = RegexPattern::compile(&pattern, 0, pe, status);
     if (U_FAILURE(status)) {
         dataerrln("RegexTest failure in RegexPattern::compile() at line %d (UTF8).  Status = %s\n",
             line, u_errorName(status));
         return FALSE;
     }
-    
+
     UnicodeString inputString(text, -1, US_INV);
     UnicodeString unEscapedInput = inputString.unescape();
     LocalUConverterPointer UTF8Converter(ucnv_open("UTF8", &status));
     ucnv_setFromUCallBack(UTF8Converter.getAlias(), UCNV_FROM_U_CALLBACK_STOP, NULL, NULL, NULL, &status);
-    
+
     inputUTF8Length = unEscapedInput.extract(NULL, 0, UTF8Converter.getAlias(), status);
     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];
     unEscapedInput.extract(textChars, inputUTF8Length+1, UTF8Converter.getAlias(), status);
     utext_openUTF8(&inputText, textChars, inputUTF8Length, &status);
-    
+
     REMatcher = &REPattern->matcher(status)->reset(&inputText);
     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)) {
@@ skipping 12 matching lines @@
         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);
+        REPattern->dumpPattern();
     }
 
     delete REPattern;
     delete REMatcher;
     utext_close(&inputText);
     utext_close(&pattern);
     delete[] textChars;
     return retVal;
 }
 
@@ skipping 45 matching lines @@
     if (status != expectedStatus) {
         dataerrln("Line %d: unexpected error %s compiling pattern.", line, u_errorName(status));
     } 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);
 }
 
 
 
 //---------------------------------------------------------------------------
 //
 //      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
     {
         // REGEX_TESTLM("a\N{LATIN SMALL LETTER B}c", "abc", FALSE, FALSE);
         UParseError pe;
         UErrorCode  status = U_ZERO_ERROR;
         RegexPattern *pattern;
         pattern = RegexPattern::compile(UNICODE_STRING_SIMPLE("a\\u00dfx").unescape(), UREGEX_CASE_INSENSITIVE, pe, status);
-        RegexPatternDump(pattern);
+        pattern->dumpPattern();
         RegexMatcher *m = pattern->matcher(UNICODE_STRING_SIMPLE("a\\u00dfxzzz").unescape(), status);
         UBool result = m->find();
         printf("result = %d\n", result);
         // REGEX_FIND("", "<0>ab<1>cc</1><2>ccc</2></0>ddd");
         // REGEX_FIND("(X([abc=X]+)+X)|(y[abc=]+)", "=XX====================");
     }
     exit(1);
 #endif
 
 
@@ skipping 127 matching lines @@
 //                 implementation.
 //
 //---------------------------------------------------------------------------
 void RegexTest::UTextBasic() {
     const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */
     UErrorCode status = U_ZERO_ERROR;
     UText pattern = UTEXT_INITIALIZER;
     utext_openUTF8(&pattern, str_abc, -1, &status);
     RegexMatcher matcher(&pattern, 0, status);
     REGEX_CHECK_STATUS;
-    
+
     UText input = UTEXT_INITIALIZER;
     utext_openUTF8(&input, str_abc, -1, &status);
     REGEX_CHECK_STATUS;
     matcher.reset(&input);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT_UTEXT_UTF8(str_abc, matcher.inputText());
-    
+
     matcher.reset(matcher.inputText());
     REGEX_CHECK_STATUS;
     REGEX_ASSERT_UTEXT_UTF8(str_abc, matcher.inputText());
-    
+
     utext_close(&pattern);
     utext_close(&input);
 }
 
 
 //---------------------------------------------------------------------------
 //
 //      API_Match   Test that the API for class RegexMatcher
 //                  is present and nominally working, but excluding functions
 //                  implementing replace operations.
@@ skipping 356 matching lines @@
         UErrorCode status = U_ZERO_ERROR;
         RegexPattern  *p = RegexPattern::compile(".", 0, status);
         RegexMatcher  *m = p->matcher(status);
         REGEX_CHECK_STATUS;
 
         REGEX_ASSERT(m->find() == FALSE);
         REGEX_ASSERT(m->input() == "");
         delete m;
         delete p;
     }
-    
+
     //
     // 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);
@@ skipping 17 matching lines @@
         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
 
     //
-    //  Time Outs.  
+    //  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;
         UnicodeString testString(1000000, 0x41, 1000000);  // Length 1,000,000, filled with 'A'
-        
+
         // 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);
     }
-    
+
 
 }
 
 
 
 
 
 
 //---------------------------------------------------------------------------
 //
@@ skipping 528 matching lines @@
         REGEX_CHECK_STATUS;
 
         UText input1 = UTEXT_INITIALIZER;
         UText input2 = UTEXT_INITIALIZER;
         UText empty  = UTEXT_INITIALIZER;
         regextst_openUTF8FromInvariant(&input1, "abcdef this is a test", -1, &status);
         REGEX_VERBOSE_TEXT(&input1);
         regextst_openUTF8FromInvariant(&input2, "not abc", -1, &status);
         REGEX_VERBOSE_TEXT(&input2);
         utext_openUChars(&empty, NULL, 0, &status);
-        
+
         int32_t input1Len = strlen("abcdef this is a test"); /* TODO: why not nativelen (input1) ? */
         int32_t input2Len = strlen("not abc");
 
 
         //
         // Matcher creation and reset.
         //
         RegexMatcher *m1 = &pat2->matcher(status)->reset(&input1);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(m1->lookingAt(status) == TRUE);
@@ skipping 89 matching lines @@
         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);
 
         delete m1;
         delete pat2;
-        
+
         utext_close(&re);
         utext_close(&input1);
         utext_close(&input2);
         utext_close(&empty);
     }
 
 
     //
     // Capture Group.
     //     RegexMatcher::start();
     //     RegexMatcher::end();
     //     RegexMatcher::groupCount();
     //
     {
         int32_t             flags=0;
         UParseError         pe;
         UErrorCode          status=U_ZERO_ERROR;
         UText               re=UTEXT_INITIALIZER;
         const char str_01234567_pat[] = { 0x30, 0x31, 0x28, 0x32, 0x33, 0x28, 0x34, 0x35, 0x29, 0x36, 0x37, 0x29, 0x28, 0x2e, 0x2a, 0x29, 0x00 }; /* 01(23(45)67)(.*) */
         utext_openUTF8(&re, str_01234567_pat, -1, &status);
-        
+
         RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
         REGEX_CHECK_STATUS;
-        
+
         UText input = UTEXT_INITIALIZER;
         const char str_0123456789[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00 }; /* 0123456789 */
         utext_openUTF8(&input, str_0123456789, -1, &status);
 
         RegexMatcher *matcher = &pat->matcher(status)->reset(&input);
         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;
@@ skipping 14 matching lines @@
 
         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);
-        
+
         UnicodeString dest;
         UText destText = UTEXT_INITIALIZER;
         utext_openUnicodeString(&destText, &dest, &status);
         UText *result;
         //const char str_0123456789[] = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00 }; /* 0123456789 */
-        //      Test shallow-clone API
+        //  Test shallow-clone API
         int64_t   group_len;
         result = matcher->group((UText *)NULL, group_len, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result);
         utext_close(result);
         result = matcher->group(0, &destText, group_len, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(result == &destText);
         REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result);
         //  destText is now immutable, reopen it
         utext_close(&destText);
         utext_openUnicodeString(&destText, &dest, &status);
-        
+
         result = matcher->group(0, NULL, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result);
         utext_close(result);
         result = matcher->group(0, &destText, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(result == &destText);
         REGEX_ASSERT_UTEXT_UTF8(str_0123456789, result);
-        
+
         result = matcher->group(1, NULL, status);
         REGEX_CHECK_STATUS;
         const char str_234567[] = { 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x00 }; /* 234567 */
         REGEX_ASSERT_UTEXT_UTF8(str_234567, result);
         utext_close(result);
         result = matcher->group(1, &destText, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(result == &destText);
         REGEX_ASSERT_UTEXT_UTF8(str_234567, result);
-        
+
         result = matcher->group(2, NULL, status);
         REGEX_CHECK_STATUS;
         const char str_45[] = { 0x34, 0x35, 0x00 }; /* 45 */
         REGEX_ASSERT_UTEXT_UTF8(str_45, result);
         utext_close(result);
         result = matcher->group(2, &destText, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(result == &destText);
         REGEX_ASSERT_UTEXT_UTF8(str_45, result);
-        
+
         result = matcher->group(3, NULL, status);
         REGEX_CHECK_STATUS;
         const char str_89[] = { 0x38, 0x39, 0x00 }; /* 89 */
         REGEX_ASSERT_UTEXT_UTF8(str_89, result);
         utext_close(result);
         result = matcher->group(3, &destText, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(result == &destText);
         REGEX_ASSERT_UTEXT_UTF8(str_89, result);
 
         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;
-        
+
         utext_close(&destText);
         utext_close(&input);
         utext_close(&re);
     }
 
     //
     //  find
     //
     {
         int32_t             flags=0;
@@ skipping 40 matching lines @@
 
         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);
 
         REGEX_ASSERT(matcher->groupCount() == 0);
 
         delete matcher;
         delete pat;
-        
+
         utext_close(&input);
         utext_close(&re);
     }
 
 
     //
     //  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;
         UText               re=UTEXT_INITIALIZER;
         const char str_Gabcabc[] = { 0x2e, 0x2a, 0x3f, 0x28, 0x3f, 0x3a, 0x28, 0x5c, 0x47, 0x61, 0x62, 0x63, 0x29, 0x7c, 0x28, 0x61, 0x62, 0x63, 0x29, 0x29, 0x00 }; /* .*?(?:(\\Gabc)|(abc)) */
         utext_openUTF8(&re, str_Gabcabc, -1, &status);
 
         RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
-        
+
         REGEX_CHECK_STATUS;
         UText input = UTEXT_INITIALIZER;
         const char str_abcabcabc[] = { 0x2e, 0x61, 0x62, 0x63, 0x61, 0x62, 0x63, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .abcabc.abc.. */
         utext_openUTF8(&input, str_abcabcabc, -1, &status);
         //                      012345678901234567
 
         RegexMatcher *matcher = &pat->matcher(status)->reset(&input);
         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);
 
         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);
     }
 
     //
     //   find with zero length matches, match position should bump ahead
     //     to prevent loops.
     //
     {
         int32_t                 i;
@@ skipping 19 matching lines @@
         utext_openUTF8(&s, (char *)aboveBMP, -1, &status);
         m.reset(&s);
         for (i=0; ; i+=4) {
             if (m.find() == FALSE) {
                 break;
             }
             REGEX_ASSERT(m.start(status) == i);
             REGEX_ASSERT(m.end(status) == i);
         }
         REGEX_ASSERT(i==20);
-        
+
         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);
     }
 
 
     //
     // 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;
 
         REGEX_ASSERT(m->find() == FALSE);
         REGEX_ASSERT(utext_nativeLength(m->inputText()) == 0);
         delete m;
         delete p;
     }
-    
+
     //
     // Regions
     //
     {
         UErrorCode status = U_ZERO_ERROR;
         UText testPattern = UTEXT_INITIALIZER;
         UText testText    = UTEXT_INITIALIZER;
         regextst_openUTF8FromInvariant(&testPattern, ".*", -1, &status);
         REGEX_VERBOSE_TEXT(&testPattern);
         regextst_openUTF8FromInvariant(&testText, "This is test data", -1, &status);
         REGEX_VERBOSE_TEXT(&testText);
-        
+
         RegexMatcher m(&testPattern, &testText, 0, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(m.regionStart() == 0);
         REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("This is test data"));
         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() == (int32_t)strlen("This is test data"));
-        
+
         regextst_openUTF8FromInvariant(&testText, "short", -1, &status);
         REGEX_VERBOSE_TEXT(&testText);
         m.reset(&testText);
         REGEX_ASSERT(m.regionStart() == 0);
         REGEX_ASSERT(m.regionEnd() == (int32_t)strlen("short"));
-        
+
         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);
-        
+
         utext_close(&testText);
         utext_close(&testPattern);
     }
-    
+
     //
     // hitEnd() and requireEnd()
     //
     {
         UErrorCode status = U_ZERO_ERROR;
         UText testPattern = UTEXT_INITIALIZER;
         UText testText    = UTEXT_INITIALIZER;
         const char str_[] = { 0x2e, 0x2a, 0x00 }; /* .* */
         const char str_aabb[] = { 0x61, 0x61, 0x62, 0x62, 0x00 }; /* aabb */
         utext_openUTF8(&testPattern, str_, -1, &status);
         utext_openUTF8(&testText, str_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;
         const char str_a[] = { 0x61, 0x2a, 0x00 }; /* a* */
         utext_openUTF8(&testPattern, str_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;
 
         status = U_ZERO_ERROR;
         const char str_dotstardollar[] = { 0x2e, 0x2a, 0x24, 0x00 }; /* .*$ */
         utext_openUTF8(&testPattern, str_dotstardollar, -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);
     }
 }
 
 
 //---------------------------------------------------------------------------
 //
 //      API_Replace_UTF8   API test for class RegexMatcher, testing the
 //                         Replace family of functions.
 //
 //---------------------------------------------------------------------------
 void RegexTest::API_Replace_UTF8() {
     //
     //  Replace
     //
     int32_t             flags=0;
     UParseError         pe;
     UErrorCode          status=U_ZERO_ERROR;
 
     UText               re=UTEXT_INITIALIZER;
     regextst_openUTF8FromInvariant(&re, "abc", -1, &status);
     REGEX_VERBOSE_TEXT(&re);
     RegexPattern *pat = RegexPattern::compile(&re, flags, pe, status);
     REGEX_CHECK_STATUS;
-    
+
     char data[] = { 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .abc..abc...abc.. */
     //             012345678901234567
     UText dataText = UTEXT_INITIALIZER;
     utext_openUTF8(&dataText, data, -1, &status);
     REGEX_CHECK_STATUS;
     REGEX_VERBOSE_TEXT(&dataText);
     RegexMatcher *matcher = &pat->matcher(status)->reset(&dataText);
 
     //
     //  Plain vanilla matches.
     //
     UnicodeString  dest;
     UText destText = UTEXT_INITIALIZER;
     utext_openUnicodeString(&destText, &dest, &status);
     UText *result;
-    
+
     UText replText = UTEXT_INITIALIZER;
-    
+
     const char str_yz[] = { 0x79, 0x7a, 0x00 }; /* yz */
     utext_openUTF8(&replText, str_yz, -1, &status);
     REGEX_VERBOSE_TEXT(&replText);
     result = matcher->replaceFirst(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     const char str_yzabcabc[] = { 0x2e, 0x79, 0x7a, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* .yz..abc...abc.. */
     REGEX_ASSERT_UTEXT_UTF8(str_yzabcabc, result);
     utext_close(result);
     result = matcher->replaceFirst(&replText, &destText, status);
     REGEX_CHECK_STATUS;
@@ skipping 11 matching lines @@
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(result == &destText);
     REGEX_ASSERT_UTEXT_UTF8(str_yzyzyz, result);
 
     //
     //  Plain vanilla non-matches.
     //
     const char str_abxabxabx[] = { 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x78, 0x2e, 0x2e, 0x00 }; /* .abx..abx...abx.. */
     utext_openUTF8(&dataText, str_abxabxabx, -1, &status);
     matcher->reset(&dataText);
-    
+
     result = matcher->replaceFirst(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result);
     utext_close(result);
     result = matcher->replaceFirst(&replText, &destText, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(result == &destText);
     REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, result);
 
     result = matcher->replaceAll(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT_UTEXT_UTF8(str_abxabxabx, 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_UTF8(str_abxabxabx, 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_UTF8("", result);
     utext_close(result);
     result = matcher->replaceFirst(&replText, &destText, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(result == &destText);
     REGEX_ASSERT_UTEXT_UTF8("", result);
 
     result = matcher->replaceAll(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT_UTEXT_UTF8("", result);
     utext_close(result);
     result = matcher->replaceAll(&replText, &destText, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(result == &destText);
     REGEX_ASSERT_UTEXT_UTF8("", 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;
     const char str_abcabc[] = { 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x2e, 0x61, 0x62, 0x63, 0x2e, 0x2e, 0x00 }; /* ...abc...abc.. */
     REGEX_ASSERT_UTEXT_UTF8(str_abcabc, result);
     utext_close(result);
     result = matcher->replaceFirst(&replText, &destText, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(result == &destText);
     REGEX_ASSERT_UTEXT_UTF8(str_abcabc, result);
@@ skipping 43 matching lines @@
     //
     const char str_add[] = { 0x61, 0x28, 0x2e, 0x2e, 0x29, 0x00 }; /* a(..) */
     utext_openUTF8(&re, str_add, -1, &status);
     RegexPattern *pat2 = RegexPattern::compile(&re, flags, pe, status);
     REGEX_CHECK_STATUS;
 
     const char str_abcdefg[] = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* abcdefg */
     utext_openUTF8(&dataText, str_abcdefg, -1, &status);
     RegexMatcher *matcher2 = &pat2->matcher(status)->reset(&dataText);
     REGEX_CHECK_STATUS;
-    
+
     const char str_11[] = { 0x24, 0x31, 0x24, 0x31, 0x00 }; /* $1$1 */
     utext_openUTF8(&replText, str_11, -1, &status);
     result = matcher2->replaceFirst(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     const char str_bcbcdefg[] = { 0x62, 0x63, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* bcbcdefg */
     REGEX_ASSERT_UTEXT_UTF8(str_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_UTF8(str_bcbcdefg, result);
-   
-    const char str_v[24] = { 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x5c, 0x24, 0x31, 0x20, 0x69, 0x73, 0x20, 0x24, 0x31, 0x2e, 0x00 }; /* The value of \$1 is $1. */ 
+
+    const char str_v[24] = { 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x5c, 0x24, 0x31, 0x20, 0x69, 0x73, 0x20, 0x24, 0x31, 0x2e, 0x00 }; /* The value of \$1 is $1. */
     utext_openUTF8(&replText, str_v, -1, &status);
     REGEX_VERBOSE_TEXT(&replText);
     result = matcher2->replaceFirst(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     const char str_Thevalueof1isbcdefg[] = { 0x54, 0x68, 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x24, 0x31, 0x20, 0x69, 0x73, 0x20, 0x62, 0x63, 0x2e, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* The value of $1 is bc.defg */
     REGEX_ASSERT_UTEXT_UTF8(str_Thevalueof1isbcdefg, 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_UTF8(str_Thevalueof1isbcdefg, result);
-    
+
     const char str_byitselfnogroupnumber[] = { 0x24, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x24, 0x24, 0x00 }; /* $ by itself, no group number $$$ */
     utext_openUTF8(&replText, str_byitselfnogroupnumber, -1, &status);
     result = matcher2->replaceFirst(&replText, NULL, status);
     REGEX_CHECK_STATUS;
     const char str_byitselfnogroupnumberdefg[] = { 0x24, 0x20, 0x62, 0x79, 0x20, 0x69, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x2c, 0x20, 0x6e, 0x6f, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x24, 0x24, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* $ by itself, no group number $$$defg */
     REGEX_ASSERT_UTEXT_UTF8(str_byitselfnogroupnumberdefg, 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_UTF8(str_byitselfnogroupnumberdefg, result);
 
     unsigned char supplDigitChars[] = { 0x53, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x20, 0x31, 0x20, 0x24, 0x78, 0x78, 0x78, 0x78, 0x2e, 0x00 }; /* Supplemental Digit 1 $xxxx. */
     //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;
     const char str_SupplementalDigit1bcdefg[] = { 0x53, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x20, 0x44, 0x69, 0x67, 0x69, 0x74, 0x20, 0x31, 0x20, 0x62, 0x63, 0x2e, 0x64, 0x65, 0x66, 0x67, 0x00 }; /* Supplemental Digit 1 bc.defg */
     REGEX_ASSERT_UTEXT_UTF8(str_SupplementalDigit1bcdefg, 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_UTF8(str_SupplementalDigit1bcdefg, result);
     const char str_badcapturegroupnumber5[] = { 0x62, 0x61, 0x64, 0x20, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x24, 0x35, 0x2e, 0x2e, 0x2e,  0x00 }; /* bad capture group number $5..." */
     utext_openUTF8(&replText, str_badcapturegroupnumber5, -1, &status);
     REGEX_ASSERT_FAIL((result = matcher2->replaceFirst(&replText, NULL, status)), U_INDEX_OUTOFBOUNDS_ERROR);
 //    REGEX_ASSERT_UTEXT_UTF8("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_UTF8("abcdefg", result);
 
     //
     // Replacement String with \u hex escapes
     //
     {
       const char str_abc1abc2abc3[] = { 0x61, 0x62, 0x63, 0x20, 0x31, 0x20, 0x61, 0x62, 0x63, 0x20, 0x32, 0x20, 0x61, 0x62, 0x63, 0x20, 0x33, 0x00 }; /* abc 1 abc 2 abc 3 */
       const char str_u0043[] = { 0x2d, 0x2d, 0x5c, 0x75, 0x30, 0x30, 0x34, 0x33, 0x2d, 0x2d, 0x00 }; /* --\u0043-- */
         utext_openUTF8(&dataText, str_abc1abc2abc3, -1, &status);
         utext_openUTF8(&replText, str_u0043, -1, &status);
         matcher->reset(&dataText);
-        
+
         result = matcher->replaceAll(&replText, NULL, status);
         REGEX_CHECK_STATUS;
         const char str_C1C2C3[] = { 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x31, 0x20, 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x32, 0x20, 0x2d, 0x2d, 0x43, 0x2d, 0x2d, 0x20, 0x33, 0x00 }; /* --C-- 1 --C-- 2 --C-- 3 */
         REGEX_ASSERT_UTEXT_UTF8(str_C1C2C3, 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_UTF8(str_C1C2C3, result);
     }
     {
       const char str_abc[] = { 0x61, 0x62, 0x63, 0x20, 0x21, 0x00 }; /* abc ! */
         utext_openUTF8(&dataText, str_abc, -1, &status);
         const char str_U00010000[] = { 0x2d, 0x2d, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x2d, 0x2d, 0x00 }; /* --\U00010000-- */
         utext_openUTF8(&replText, str_U00010000, -1, &status);
         matcher->reset(&dataText);
 
         unsigned char expected[] = { 0x2d, 0x2d, 0x78, 0x78, 0x78, 0x78, 0x2d, 0x2d, 0x20, 0x21, 0x00 }; /* --xxxx-- ! */ // \U00010000, "LINEAR B SYLLABLE B008 A"
-        //                          0123456789     
+        //                          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_UTF8((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_UTF8((char *)expected, result);
     }
     // TODO:  need more through testing of capture substitutions.
 
     // Bug 4057
     //
     {
         status = U_ZERO_ERROR;
 const char str_ssee[] = { 0x73, 0x73, 0x28, 0x2e, 0x2a, 0x3f, 0x29, 0x65, 0x65, 0x00 }; /* ss(.*?)ee */
 const char str_blah[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x73, 0x73, 0x20, 0x73, 0x74, 0x75, 0x66, 0x66, 0x20, 0x65, 0x65, 0x20, 0x66, 0x69, 0x6e, 0x00 }; /* The matches start with ss and end with ee ss stuff ee fin */
 const char str_ooh[] = { 0x6f, 0x6f, 0x68, 0x00 }; /* ooh */
         utext_openUTF8(&re, str_ssee, -1, &status);
         utext_openUTF8(&dataText, str_blah, -1, &status);
         utext_openUTF8(&replText, str_ooh, -1, &status);
-        
+
         RegexMatcher m(&re, 0, status);
         REGEX_CHECK_STATUS;
-        
+
         UnicodeString result;
         UText resultText = UTEXT_INITIALIZER;
         utext_openUnicodeString(&resultText, &result, &status);
 
         // 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;
@@ skipping 20 matching lines @@
         m.find(10, status);
         m.find();
         m.appendReplacement(&resultText, &replText, status);
         REGEX_CHECK_STATUS;
         const char str_blah8[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x00 }; /* The matches start with ss and end with ee ooh */
         REGEX_ASSERT_UTEXT_UTF8(str_blah8, &resultText);
 
         m.appendTail(&resultText, status);
         const char str_blah9[] = { 0x54, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x65, 0x65, 0x20, 0x6f, 0x6f, 0x68, 0x20, 0x66, 0x69, 0x6e, 0x00 }; /* The matches start with ss and end with ee ooh fin */
         REGEX_ASSERT_UTEXT_UTF8(str_blah9, &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;
-    
+
     const char str_abcalmz[] = { 0x61, 0x62, 0x63, 0x5b, 0x61, 0x2d, 0x6c, 0x5d, 0x5b, 0x6d, 0x2d, 0x7a, 0x5d, 0x00 }; /* abc[a-l][m-z] */
     const char str_def[] = { 0x64, 0x65, 0x66, 0x00 }; /* def */
     utext_openUTF8(&re1, str_abcalmz, -1, &status);
     utext_openUTF8(&re2, str_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);
@@ skipping 28 matching lines @@
 
     // 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);
 
 
     //
     //   Verify that a matcher created from a cloned pattern works.
     //     (Jitterbug 3423)
     //
     {
         UErrorCode     status     = U_ZERO_ERROR;
         UText          pattern    = UTEXT_INITIALIZER;
         const char str_pL[] = { 0x5c, 0x70, 0x7b, 0x4c, 0x7d, 0x2b, 0x00 }; /* \p{L}+ */
         utext_openUTF8(&pattern, str_pL, -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;
         const char str_HelloWorld[] = { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x00 }; /* Hello World */
         utext_openUTF8(&input, str_HelloWorld, -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;
-        
+
         const char str_randominput[] = { 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x00 }; /* random input */
         utext_openUTF8(&input, str_randominput, -1, &status);
 
         const char str_dotstar[] = { 0x2e, 0x2a, 0x00 }; /* .* */
         utext_openUTF8(&pattern, str_dotstar, -1, &status);
         REGEX_ASSERT(RegexPattern::matches(&pattern, &input, pe, status) == TRUE);
         REGEX_CHECK_STATUS;
-        
+
         const char str_abc[] = { 0x61, 0x62, 0x63, 0x00 }; /* abc */
         utext_openUTF8(&pattern, str_abc, -1, &status);
         REGEX_ASSERT(RegexPattern::matches("abc", "random input", pe, status) == FALSE);
         REGEX_CHECK_STATUS;
-        
+
         const char str_nput[] = { 0x2e, 0x2a, 0x6e, 0x70, 0x75, 0x74, 0x00 }; /* .*nput */
         utext_openUTF8(&pattern, str_nput, -1, &status);
         REGEX_ASSERT(RegexPattern::matches(".*nput", "random input", pe, status) == TRUE);
         REGEX_CHECK_STATUS;
-        
+
         utext_openUTF8(&pattern, str_randominput, -1, &status);
         REGEX_ASSERT(RegexPattern::matches("random input", "random input", pe, status) == TRUE);
         REGEX_CHECK_STATUS;
 
         const char str_u[] = { 0x2e, 0x2a, 0x75, 0x00 }; /* .*u */
         utext_openUTF8(&pattern, str_u, -1, &status);
         REGEX_ASSERT(RegexPattern::matches(".*u", "random input", pe, status) == FALSE);
         REGEX_CHECK_STATUS;
-        
+
         utext_openUTF8(&input, str_abc, -1, &status);
         utext_openUTF8(&pattern, str_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;
     const char str_spaceplus[] = { 0x20, 0x2b, 0x00 }; /*  + */
@@ skipping 370 matching lines @@
 }
 
 
 void RegexTest::regex_find(const UnicodeString &pattern,
                            const UnicodeString &flags,
                            const UnicodeString &inputString,
                            const char *srcPath,
                            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);
     UVector             groupStartsUTF8(status);
     UVector             groupEndsUTF8(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;
     int32_t             regionStartUTF8  = -1;
     int32_t             regionEndUTF8    = -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;
     }
     if (flags.indexOf((UChar)0x51) >= 0) { // 'Q' flag
         bflags |= UREGEX_LITERAL;
     }
 
@@ skipping 15 matching lines @@
             goto cleanupAndReturn;
         } else {
             // Unexpected pattern compilation error.
             dataerrln("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 %s:%d", srcPath, line);
         status = U_ZERO_ERROR;
     }
 
     if (flags.indexOf((UChar)0x64) >= 0) {  // 'd' flag
-        RegexPatternDump(callerPattern);
+        callerPattern->dumpPattern();
     }
 
     if (flags.indexOf((UChar)0x45) >= 0) {  // 'E' flag
         errln("%s, Line %d: Expected, but did not get, a pattern compilation error.", srcPath, line);
         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
@@ skipping 34 matching lines @@
     }
 
     //
     //  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) {
             UTF8Matcher = &UTF8Pattern->matcher(status)->reset(&inputText);
             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 %s:%d", srcPath, line);
             status = U_ZERO_ERROR;
         }
     }
 
     //
     //  Generate native indices for UTF8 versions of region and capture group info
     //
     if (UTF8Matcher != NULL) {
         if (regionStart>=0)    (void) utextOffsetToNative(&inputText, regionStart, regionStartUTF8);
         if (regionEnd>=0)      (void) utextOffsetToNative(&inputText, regionEnd, regionEndUTF8);
-       
+
         //  Fill out the native index UVector info.
         //  Only need 1 loop, from above we know groupStarts.size() = groupEnds.size()
         for (i=0; i<groupStarts.size(); i++) {
             int32_t  start = groupStarts.elementAti(i);
             //  -1 means there was no UVector slot and we won't be requesting that capture group for this test, don't bother inserting
             if (start >= 0) {
                 int32_t  startUTF8;
                 if (!utextOffsetToNative(&inputText, start, startUTF8)) {
                     errln("Error at line %d: could not find native index for group start %d.  UTF16 index %d", line, i, start);
                     failed = TRUE;
                     goto cleanupAndReturn;  // Good chance of subsequent bogus errors.  Stop now.
                 }
                 setInt(groupStartsUTF8, startUTF8, i);
             }
-            
+
             int32_t  end = groupEnds.elementAti(i);
             //  -1 means there was no UVector slot and we won't be requesting that capture group for this test, don't bother inserting
             if (end >= 0) {
                 int32_t  endUTF8;
                 if (!utextOffsetToNative(&inputText, end, endUTF8)) {
                     errln("Error at line %d: could not find native index for group end %d.  UTF16 index %d", line, i, end);
                     failed = TRUE;
                     goto cleanupAndReturn;  // Good chance of subsequent bogus errors.  Stop now.
                 }
                 setInt(groupEndsUTF8, endUTF8, i);
@@ skipping 14 matching lines @@
         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) {
@@ skipping 54 matching lines @@
             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) != expectedStartUTF8) {
             errln("Error at line %d: incorrect start position for group %d.  Expected %d, got %d (UTF8)",
                   line, i, expectedStartUTF8, 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));
         int32_t  expectedEndUTF8 = (i >= groupEndsUTF8.size()? -1 : groupEndsUTF8.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) != expectedEndUTF8) {
             errln("Error at line %d: incorrect end position for group %d.  Expected %d, got %d (UTF8)",
@@ skipping 16 matching lines @@
 
     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);
 }
 
 
 
 
@@ skipping 55 matching lines @@
     // 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;
@@ skipping 322 matching lines @@
         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,
@@ skipping 277 matching lines @@
         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;
         }
-        
+
         //
         // Put the pattern in a UTF-8 UText
         //
         status = U_ZERO_ERROR;
         patternLength = pattern.extract(patternChars, patternCapacity, UTF8Converter.getAlias(), status);
         if (status == U_BUFFER_OVERFLOW_ERROR) {
             status = U_ZERO_ERROR;
             delete[] patternChars;
             patternCapacity = patternLength + 1;
             patternChars = new char[patternCapacity];
@@ skipping 76 matching lines @@
         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,
@@ skipping 122 matching lines @@
     delete groupsPat;
 
     delete flagMat;
     delete flagPat;
 
     delete lineMat;
     delete linePat;
 
     delete fieldPat;
     delete [] testData;
-    
+
     utext_close(&patternText);
     utext_close(&inputText);
-    
+
     delete [] patternChars;
     delete [] inputChars;
 
 
     logln("%d tests skipped because of unimplemented regexp features.", skippedUnimplementedCount);
 
 }
 
 
 //--------------------------------------------------------------
@@ skipping 43 matching lines @@
     }
     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;
         URegexMatchCallback *returnedFn = &testCallBackFn;
-        
+
         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;
         URegexMatchCallback *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.setMatchCallback(testCallBackFn, &cbInfo, status);
         REGEX_CHECK_STATUS;
         matcher.getMatchCallback(returnedFn, returnedContext, status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(returnedFn == testCallBackFn);
         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);
     }
- 
+
 
 }
 
 
 //
 //   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;};
 };
 
+// call-back function for find().
+// Return TRUE to continue the find().
+// Return FALSE to stop the find().
 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.
+        RegexMatcher matcher(UNICODE_STRING_SIMPLE("((.)\\2)x"), 0, status);
         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.
+
+        // A find that matches on the initial position does NOT invoke the callback.
         status = U_ZERO_ERROR;
         cbInfo.reset(100);
-        UnicodeString s = "abxxx";
+        UnicodeString s = "aaxxx";
         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.
+
+        // A medium running find() that causes matcher.find() to invoke our callback for each index,
+        //   but not so many times that we interrupt the operation.
         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(status == U_REGEX_STOPPED_BY_CALLER);
         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;
+        REGEX_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
         // Now retry the match from where left off
         cbInfo.maxCalls = 100; //  No callback limit
+        status = U_ZERO_ERROR;
         REGEX_ASSERT(matcher.find(cbInfo.lastIndex, status));
         REGEX_CHECK_STATUS;
-#endif
     }
- 
+
 
 }
 
 
 //---------------------------------------------------------------------------
 //
 //    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;
         regextst_openUTF8FromInvariant(&text1, "abcccd", -1, &status);
         regextst_openUTF8FromInvariant(&text2, "abcccxd", -1, &status);
         u_uastrncpy(text2Chars, "abcccxd", sizeof(text2)/2);
         utext_openUChars(&text2, text2Chars, -1, &status);
-        
+
         regextst_openUTF8FromInvariant(&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(testUTextEqual(resultText, &text1));
-        
+
         resultText = uregex_getUText(re, &bufferText, &status);
         REGEX_CHECK_STATUS;
         REGEX_ASSERT(resultText == &bufferText);
         utext_setNativeIndex(resultText, 0);
         utext_setNativeIndex(&text1, 0);
         REGEX_ASSERT(testUTextEqual(resultText, &text1));
 
         /* 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(testUTextEqual(resultText, &text2));
-        
+
         uregex_close(re);
         utext_close(&text1);
         utext_close(&text2);
     }
 
     /*
      *  group()
      */
     {
         UChar    text1[80];
@@ skipping 25 matching lines @@
 
         /*  Capture group out of range.  Error. */
         status = U_ZERO_ERROR;
         actual = uregex_groupUTextDeep(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);
         regextst_openUTF8FromInvariant(&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_INVARIANT("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_INVARIANT("No match here.", result);
-        
+
         /* Unicode escapes */
         uregex_setText(re, text1, -1, &status);
         regextst_openUTF8FromInvariant(&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_INVARIANT("Replace \\AaaB$a x1x x...x.", result);
 
         uregex_close(re);
@@ skipping 36 matching lines @@
 
         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);
     utext_close(&patternText);
 }
 
 //--------------------------------------------------------------
 //
 //  Bug7651   Regex pattern that exceeds default operator stack depth in matcher.
 //
 //---------------------------------------------------------------
 void RegexTest::Bug7651() {
@@ skipping 54 matching lines @@
     {
         UnicodeString str;
         str.setToBogus();
         pMatcher->reset(str);
         status = U_ZERO_ERROR;
         pMatcher->matches(status);
         REGEX_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
         delete pMatcher;
     }
 }
-     
+
 
 // Bug 7029
 void RegexTest::Bug7029() {
     UErrorCode status = U_ZERO_ERROR;
 
     RegexMatcher* const pMatcher = new RegexMatcher(".", 0, status);
     UnicodeString text = "abc.def";
     UnicodeString splits[10];
     REGEX_CHECK_STATUS;
     int32_t numFields = pMatcher->split(text, splits, 10, status);
     REGEX_CHECK_STATUS;
     REGEX_ASSERT(numFields == 8);
     delete pMatcher;
 }
 
 // Bug 9283
 //   This test is checking for the existance of any supplemental characters that case-fold
-//   to a bmp character.  
+//   to a bmp character.
 //
-//   At the time of this writing there are none. If any should appear in a subsequent release 
-//   of Unicode, the code in regular expressions compilation that determines the longest 
-//   posssible match for a literal string  will need to be enhanced.  
+//   At the time of this writing there are none. If any should appear in a subsequent release
+//   of Unicode, the code in regular expressions compilation that determines the longest
+//   posssible match for a literal string  will need to be enhanced.
 //
 //   See file regexcmp.cpp, case URX_STRING_I in RegexCompile::maxMatchLength()
 //   for details on what to do in case of a failure of this test.
 //
 void RegexTest::Bug9283() {
+#if !UCONFIG_NO_NORMALIZATION
     UErrorCode status = U_ZERO_ERROR;
     UnicodeSet supplementalsWithCaseFolding("[[:CWCF:]&[\\U00010000-\\U0010FFFF]]", status);
     REGEX_CHECK_STATUS;
     int32_t index;
     UChar32 c;
     for (index=0; ; index++) {
         c = supplementalsWithCaseFolding.charAt(index);
         if (c == -1) {
             break;
         }
         UnicodeString cf = UnicodeString(c).foldCase();
         REGEX_ASSERT(cf.length() >= 2);
     }
+#endif /* #if !UCONFIG_NO_NORMALIZATION */
 }
 
 
 void RegexTest::CheckInvBufSize() {
   if(inv_next>=INV_BUFSIZ) {
     errln("%s: increase #define of INV_BUFSIZ ( is %d but needs to be at least %d )\n",
           __FILE__, INV_BUFSIZ, inv_next);
   } else {
     logln("%s: INV_BUFSIZ is %d, usage %d\n", __FILE__, INV_BUFSIZ, inv_next);
   }
 }
 
-void RegexTest::TestBug11371() {
+
+void RegexTest::Bug10459() {
     UErrorCode status = U_ZERO_ERROR;
-    UnicodeString patternString;
+    UnicodeString patternString("(txt)");
+    UnicodeString txtString("txt");
 
-    for (int i=0; i<8000000; i++) {
-        patternString.append(UnicodeString("()"));
+    UText *utext_pat = utext_openUnicodeString(NULL, &patternString, &status);
+    REGEX_CHECK_STATUS;
+    UText *utext_txt = utext_openUnicodeString(NULL, &txtString, &status);
+    REGEX_CHECK_STATUS;
+
+    URegularExpression *icu_re = uregex_openUText(utext_pat, 0, NULL, &status);
+    REGEX_CHECK_STATUS;
+
+    uregex_setUText(icu_re, utext_txt, &status);
+    REGEX_CHECK_STATUS;
+
+    // The bug was that calling uregex_group() before doing a matching operation
+    //   was causing a segfault. Only for Regular Expressions created from UText.
+    //   It should set an U_REGEX_INVALID_STATE.
+
+    UChar buf[100];
+    int32_t len = uregex_group(icu_re, 0, buf, UPRV_LENGTHOF(buf), &status);
+    REGEX_ASSERT(status == U_REGEX_INVALID_STATE);
+    REGEX_ASSERT(len == 0);
+
+    uregex_close(icu_re);
+    utext_close(utext_pat);
+    utext_close(utext_txt);
+}
+
+void RegexTest::TestCaseInsensitiveStarters() {
+    // Test that the data used by RegexCompile::findCaseInsensitiveStarters() hasn't
+    //  become stale because of new Unicode characters.
+    // If it is stale, rerun the generation tool
+    //    svn+ssh://source.icu-project.org/repos/icu/tools/trunk/unicode/c/genregexcasing
+    // and replace the embedded data in i18n/regexcmp.cpp
+
+    for (UChar32 cp=0; cp<=0x10ffff; cp++) {
+        if (!u_hasBinaryProperty(cp, UCHAR_CASE_SENSITIVE)) {
+            continue;
+        }
+        UnicodeSet s(cp, cp);
+        s.closeOver(USET_CASE_INSENSITIVE);
+        UnicodeSetIterator setIter(s);
+        while (setIter.next()) {
+            if (!setIter.isString()) {
+                continue;
+            }
+            const UnicodeString &str = setIter.getString();
+            UChar32 firstChar = str.char32At(0);
+            UnicodeSet starters;
+            RegexCompile::findCaseInsensitiveStarters(firstChar, &starters);
+            if (!starters.contains(cp)) {
+                errln("CaseInsensitiveStarters for \\u%x is missing character \\u%x.", cp, firstChar);
+                return;
+            }
+        }
     }
+}
+
+
+void RegexTest::TestBug11049() {
+    // Original bug report: pattern with match start consisting of one of several individual characters,
+    //  and the text being matched ending with a supplementary character. find() would read past the
+    //  end of the input text when searching for potential match starting points.
+
+    // To see the problem, the text must exactly fill an allocated buffer, so that valgrind will
+    // detect the bad read.
+
+    TestCase11049("A|B|C", "a string \\ud800\\udc00", FALSE, __LINE__);
+    TestCase11049("A|B|C", "string matches at end C", TRUE, __LINE__);
+
+    // Test again with a pattern starting with a single character,
+    // which takes a different code path than starting with an OR expression,
+    // but with similar logic.
+    TestCase11049("C", "a string \\ud800\\udc00", FALSE, __LINE__);
+    TestCase11049("C", "string matches at end C", TRUE, __LINE__);
+}
+
+// Run a single test case from TestBug11049(). Internal function.
+void RegexTest::TestCase11049(const char *pattern, const char *data, UBool expectMatch, int32_t lineNumber) {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString patternString = UnicodeString(pattern).unescape();
     LocalPointer<RegexPattern> compiledPat(RegexPattern::compile(patternString, 0, status));
-    if (status != U_REGEX_PATTERN_TOO_BIG) {
-        errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
-              __FILE__, __LINE__, u_errorName(status));
+
+    UnicodeString dataString = UnicodeString(data).unescape();
+    UChar *exactBuffer = new UChar[dataString.length()];
+    dataString.extract(exactBuffer, dataString.length(), status);
+    UText *ut = utext_openUChars(NULL, exactBuffer, dataString.length(), &status);
+
+    LocalPointer<RegexMatcher> matcher(compiledPat->matcher(status));
+    REGEX_CHECK_STATUS;
+    matcher->reset(ut);
+    UBool result = matcher->find();
+    if (result != expectMatch) {
+        errln("File %s, line %d: expected %d, got %d. Pattern = \"%s\", text = \"%s\"",
+              __FILE__, lineNumber, expectMatch, result, pattern, data);
     }
 
-    status = U_ZERO_ERROR;
-    patternString = "(";
-    for (int i=0; i<20000000; i++) {
-        patternString.append(UnicodeString("A++"));
+    // Rerun test with UTF-8 input text. Won't see buffer overreads, but could see
+    //   off-by-one on find() with match at the last code point.
+    //   Size of the original char * data (invariant charset) will be <= than the equivalent UTF-8
+    //   because string.unescape() will only shrink it.
+    char * utf8Buffer = new char[uprv_strlen(data)+1];
+    u_strToUTF8(utf8Buffer, uprv_strlen(data)+1, NULL, dataString.getBuffer(), dataString.length(), &status);
+    REGEX_CHECK_STATUS;
+    ut = utext_openUTF8(ut, utf8Buffer, -1, &status);
+    REGEX_CHECK_STATUS;
+    matcher->reset(ut);
+    result = matcher->find();
+    if (result != expectMatch) {
+        errln("File %s, line %d (UTF-8 check): expected %d, got %d. Pattern = \"%s\", text = \"%s\"",
+              __FILE__, lineNumber, expectMatch, result, pattern, data);
     }
-    patternString.append(UnicodeString("){0}B++"));
-    LocalPointer<RegexPattern> compiledPat2(RegexPattern::compile(patternString, 0, status));
-    if (status != U_REGEX_PATTERN_TOO_BIG) {
-        errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
-              __FILE__, __LINE__, u_errorName(status));
-    }
+    delete [] utf8Buffer;
 
-    // Pattern with too much string data, such that string indexes overflow operand data.
-    status = U_ZERO_ERROR;
-    patternString = "";
-    while (patternString.length() < 0x00ffffff) {
-        patternString.append(UnicodeString("stuff and things dont you know, these are a few of my favorite strings\n"));
-    }
-    patternString.append(UnicodeString("X? trailing string"));
-    LocalPointer<RegexPattern> compiledPat3(RegexPattern::compile(patternString, 0, status));
-    compiledPat3->dumpPattern();
-    if (status != U_REGEX_PATTERN_TOO_BIG) {
-        errln("File %s, line %d expected status=U_REGEX_PATTERN_TOO_BIG; got %s.",
-              __FILE__, __LINE__, u_errorName(status));
-    }
+    utext_close(ut);
+    delete [] exactBuffer;
+}
 
 
 
-}
+#endif  /* !UCONFIG_NO_REGULAR_EXPRESSIONS  */
 
-#endif  /* !UCONFIG_NO_REGULAR_EXPRESSIONS  */