Update ICU to 54.1 step 1

source/test/cintltst/reapits.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 2004-2013, International Business Machines Corporation and
+ * Copyright (c) 2004-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /********************************************************************************
 *
 * File reapits.c
 *
 *********************************************************************************/
 /*C API TEST FOR Regular Expressions */
 /**
 *   This is an API test for ICU regular expressions in C.  It doesn't test very many cases, and doesn't
 *   try to test the full functionality.  It just calls each function and verifies that it
 *   works on a basic level.
 *
 *   More complete testing of regular expression functionality is done with the C++ tests.
 **/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 
 #include <stdlib.h>
 #include <string.h>
 #include "unicode/uloc.h"
 #include "unicode/uregex.h"
 #include "unicode/ustring.h"
 #include "unicode/utext.h"
 #include "cintltst.h"
+#include "cmemory.h"
 
 #define TEST_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
-log_data_err("Failure at file %s, line %d, error = %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));}}
+log_data_err("Failure at file %s:%d - error = %s (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));}}
 
 #define TEST_ASSERT(expr) {if ((expr)==FALSE) { \
-log_data_err("Test Failure at file %s, line %d (Are you missing data?)\n", __FILE__, __LINE__);}}
+log_err("Test Failure at file %s:%d - ASSERT(%s) failed.\n", __FILE__, __LINE__, #expr);}}
 
 /*
  *   TEST_SETUP and TEST_TEARDOWN
  *         macros to handle the boilerplate around setting up regex test cases.
  *         parameteres to setup:
  *              pattern:     The regex pattern, a (char *) null terminated C string.
  *              testString:  The string data, also a (char *) C string.
  *              flags:       Regex flags to set when compiling the pattern
  *
  *         Put arbitrary test code between SETUP and TEARDOWN.
@@ skipping 104 matching lines @@
 }
 
     
 
 
 static void TestRegexCAPI(void);
 static void TestBug4315(void);
 static void TestUTextAPI(void);
 static void TestRefreshInput(void);
 static void TestBug8421(void);
+static void TestBug10815(void);
 
 void addURegexTest(TestNode** root);
 
 void addURegexTest(TestNode** root)
 {
     addTest(root, &TestRegexCAPI, "regex/TestRegexCAPI");
     addTest(root, &TestBug4315,   "regex/TestBug4315");
     addTest(root, &TestUTextAPI,  "regex/TestUTextAPI");
     addTest(root, &TestRefreshInput, "regex/TestRefreshInput");
     addTest(root, &TestBug8421,   "regex/TestBug8421");
+    addTest(root, &TestBug10815,   "regex/TestBug10815");
 }
 
 /*
  * Call back function and context struct used for testing
  *    regular expression user callbacks.  This test is mostly the same as
  *   the corresponding C++ test in intltest. 
  */
 typedef struct callBackContext {
     int32_t          maxCalls;
     int32_t          numCalls;
@@ skipping 16 matching lines @@
  */
 static void TestRegexCAPI(void) {
     UErrorCode           status = U_ZERO_ERROR;
     URegularExpression  *re;
     UChar                pat[200];
     UChar               *minus1;
 
     memset(&minus1, -1, sizeof(minus1));
 
     /* Mimimalist open/close */
-    u_uastrncpy(pat, "abc*", sizeof(pat)/2);
+    u_uastrncpy(pat, "abc*", UPRV_LENGTHOF(pat));
     re = uregex_open(pat, -1, 0, 0, &status);
     if (U_FAILURE(status)) {
          log_data_err("Failed to open regular expression, %s:%d, error is \"%s\" (Are you missing data?)\n", __FILE__, __LINE__, u_errorName(status));
          return;
     }
     uregex_close(re);
 
     /* Open with all flag values set */
     status = U_ZERO_ERROR;
     re = uregex_open(pat, -1, 
@@ skipping 31 matching lines @@
         const UChar   *p;
         int32_t  len;
         status = U_ZERO_ERROR;
         re = uregex_openC("abc*", 0, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         p = uregex_pattern(re, &len, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS above should change too... */
         if(U_SUCCESS(status)) {
-            u_uastrncpy(pat, "abc*", sizeof(pat)/2);
+            u_uastrncpy(pat, "abc*", UPRV_LENGTHOF(pat));
             TEST_ASSERT(u_strcmp(pat, p) == 0);
             TEST_ASSERT(len==(int32_t)strlen("abc*"));
         }
 
         uregex_close(re);
 
         /*  TODO:  Open with ParseError parameter */
     }
 
     /*
@@ skipping 19 matching lines @@
         clone2 = uregex_clone(re, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(clone2 != NULL);
         uregex_close(re);
 
         status = U_ZERO_ERROR;
         clone3 = uregex_clone(clone2, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(clone3 != NULL);
 
-        u_uastrncpy(testString1, "abcccd", sizeof(pat)/2);
-        u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2);
+        u_uastrncpy(testString1, "abcccd", UPRV_LENGTHOF(pat));
+        u_uastrncpy(testString2, "xxxabcccd", UPRV_LENGTHOF(pat));
 
         status = U_ZERO_ERROR;
         uregex_setText(clone1, testString1, -1, &status);
         TEST_ASSERT_SUCCESS(status);
         result = uregex_lookingAt(clone1, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(result==TRUE);
         
         status = U_ZERO_ERROR;
         uregex_setText(clone2, testString2, -1, &status);
@@ skipping 10 matching lines @@
         uregex_close(clone3);
 
     }
 
     /*
      *  pattern()
     */
     {
         const UChar  *resultPat;
         int32_t       resultLen;
-        u_uastrncpy(pat, "hello", sizeof(pat)/2);
+        u_uastrncpy(pat, "hello", UPRV_LENGTHOF(pat));
         status = U_ZERO_ERROR;
         re = uregex_open(pat, -1, 0, NULL, &status);
         resultPat = uregex_pattern(re, &resultLen, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS above should change too... */
         if (U_SUCCESS(status)) {
             TEST_ASSERT(resultLen == -1);
             TEST_ASSERT(u_strcmp(resultPat, pat) == 0);
         }
@@ skipping 45 matching lines @@
     }
 
     /*
      *  setText() and lookingAt()
      */
     {
         UChar  text1[50];
         UChar  text2[50];
         UBool  result;
 
-        u_uastrncpy(text1, "abcccd",  sizeof(text1)/2);
-        u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
+        u_uastrncpy(text1, "abcccd",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "abcccxd", UPRV_LENGTHOF(text2));
         status = U_ZERO_ERROR;
-        u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
+        u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
         re = uregex_open(pat, -1, 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* Operation before doing a setText should fail... */
         status = U_ZERO_ERROR;
         uregex_lookingAt(re, 0, &status);
         TEST_ASSERT( status== U_REGEX_INVALID_STATE);
 
         status = U_ZERO_ERROR;
         uregex_setText(re, text1, -1, &status);
@@ skipping 31 matching lines @@
 
     /*
      *  getText() 
      */
     {
         UChar    text1[50];
         UChar    text2[50];
         const UChar   *result;
         int32_t  textLength;
 
-        u_uastrncpy(text1, "abcccd",  sizeof(text1)/2);
-        u_uastrncpy(text2, "abcccxd", sizeof(text2)/2);
+        u_uastrncpy(text1, "abcccd",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "abcccxd", UPRV_LENGTHOF(text2));
         status = U_ZERO_ERROR;
-        u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
+        u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
         re = uregex_open(pat, -1, 0, NULL, &status);
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_getText(re, &textLength, &status);
         TEST_ASSERT(result == text1);
         TEST_ASSERT(textLength == -1);
         TEST_ASSERT_SUCCESS(status);
 
         status = U_ZERO_ERROR;
         uregex_setText(re, text2, 7, &status);
@@ skipping 13 matching lines @@
 
     /*
      *  matches()
      */
     {
         UChar   text1[50];
         UBool   result;
         int     len;
         UChar   nullString[] = {0,0,0};
 
-        u_uastrncpy(text1, "abcccde",  sizeof(text1)/2);
+        u_uastrncpy(text1, "abcccde",  UPRV_LENGTHOF(text1));
         status = U_ZERO_ERROR;
-        u_uastrncpy(pat, "abc*d", sizeof(pat)/2);
+        u_uastrncpy(pat, "abc*d", UPRV_LENGTHOF(pat));
         re = uregex_open(pat, -1, 0, NULL, &status);
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_matches(re, 0, &status);
         TEST_ASSERT(result == FALSE);
         TEST_ASSERT_SUCCESS(status);
 
         status = U_ZERO_ERROR;
         uregex_setText(re, text1, 6, &status);
         result = uregex_matches(re, 0, &status);
@@ skipping 29 matching lines @@
      *  lookingAt()    Used in setText test.
      */
 
 
     /*
      *  find(), findNext, start, end, reset
      */
     {
         UChar    text1[50];
         UBool    result;
-        u_uastrncpy(text1, "012rx5rx890rxrx...",  sizeof(text1)/2);
+        u_uastrncpy(text1, "012rx5rx890rxrx...",  UPRV_LENGTHOF(text1));
         status = U_ZERO_ERROR;
         re = uregex_openC("rx", 0, NULL, &status);
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_find(re, 0, &status);
         TEST_ASSERT(result == TRUE);
         TEST_ASSERT(uregex_start(re, 0, &status) == 3);
         TEST_ASSERT(uregex_end(re, 0, &status) == 5);
         TEST_ASSERT_SUCCESS(status);
 
@@ skipping 62 matching lines @@
 
 
     /*
      *  group()
      */
     {
         UChar    text1[80];
         UChar    buf[80];
         UBool    result;
         int32_t  resultSz;
-        u_uastrncpy(text1, "noise abc interior def, and this is off the end",  sizeof(text1)/2);
+        u_uastrncpy(text1, "noise abc interior def, and this is off the end",  UPRV_LENGTHOF(text1));
 
         status = U_ZERO_ERROR;
         re = uregex_openC("abc(.*?)def", 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_find(re, 0, &status);
         TEST_ASSERT(result==TRUE);
 
         /*  Capture Group 0, the full match.  Should succeed.  */
         status = U_ZERO_ERROR;
-        resultSz = uregex_group(re, 0, buf, sizeof(buf)/2, &status);
+        resultSz = uregex_group(re, 0, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("abc interior def", buf, TRUE);
         TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
 
         /*  Capture group #1.  Should succeed. */
         status = U_ZERO_ERROR;
-        resultSz = uregex_group(re, 1, buf, sizeof(buf)/2, &status);
+        resultSz = uregex_group(re, 1, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING(" interior ", buf, TRUE);
         TEST_ASSERT(resultSz == (int32_t)strlen(" interior "));
 
         /*  Capture group out of range.  Error. */
         status = U_ZERO_ERROR;
-        uregex_group(re, 2, buf, sizeof(buf)/2, &status);
+        uregex_group(re, 2, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
 
         /* NULL buffer, pure pre-flight */
         status = U_ZERO_ERROR;
         resultSz = uregex_group(re, 0, NULL, 0, &status);
         TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
         TEST_ASSERT(resultSz == (int32_t)strlen("abc interior def"));
 
         /* Too small buffer, truncated string */
         status = U_ZERO_ERROR;
@@ skipping 23 matching lines @@
         
         /* SetRegion(), getRegion() do something  */
         TEST_SETUP(".*", "0123456789ABCDEF", 0)
         UChar resultString[40];
         TEST_ASSERT(uregex_regionStart(re, &status) == 0);
         TEST_ASSERT(uregex_regionEnd(re, &status) == 16);
         uregex_setRegion(re, 3, 6, &status);
         TEST_ASSERT(uregex_regionStart(re, &status) == 3);
         TEST_ASSERT(uregex_regionEnd(re, &status) == 6);
         TEST_ASSERT(uregex_findNext(re, &status));
-        TEST_ASSERT(uregex_group(re, 0, resultString, sizeof(resultString)/2, &status) == 3)
+        TEST_ASSERT(uregex_group(re, 0, resultString, UPRV_LENGTHOF(resultString), &status) == 3)
         TEST_ASSERT_STRING("345", resultString, TRUE);
         TEST_TEARDOWN;
         
         /* find(start=-1) uses regions   */
         TEST_SETUP(".*", "0123456789ABCDEF", 0);
         uregex_setRegion(re, 4, 6, &status);
         TEST_ASSERT(uregex_find(re, -1, &status) == TRUE);
         TEST_ASSERT(uregex_start(re, 0, &status) == 4);
         TEST_ASSERT(uregex_end(re, 0, &status) == 6);
         TEST_TEARDOWN;
@@ skipping 103 matching lines @@
 
     /*
      *  replaceFirst()
      */
     {
         UChar    text1[80];
         UChar    text2[80];
         UChar    replText[80];
         UChar    buf[80];
         int32_t  resultSz;
-        u_uastrncpy(text1, "Replace xaax x1x x...x.",  sizeof(text1)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
-        u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
+        u_uastrncpy(text1, "Replace xaax x1x x...x.",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
+        u_uastrncpy(replText, "<$1>", UPRV_LENGTHOF(replText));
 
         status = U_ZERO_ERROR;
         re = uregex_openC("x(.*?)x", 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /*  Normal case, with match */
         uregex_setText(re, text1, -1, &status);
-        resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
+        resultSz = uregex_replaceFirst(re, replText, -1, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("Replace <aa> x1x x...x.", buf, TRUE);
         TEST_ASSERT(resultSz == (int32_t)strlen("Replace xaax x1x x...x."));
 
         /* No match.  Text should copy to output with no changes.  */
         status = U_ZERO_ERROR;
         uregex_setText(re, text2, -1, &status);
-        resultSz = uregex_replaceFirst(re, replText, -1, buf, sizeof(buf)/2, &status);
+        resultSz = uregex_replaceFirst(re, replText, -1, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("No match here.", buf, TRUE);
         TEST_ASSERT(resultSz == (int32_t)strlen("No match here."));
 
         /*  Match, output just fills buffer, no termination warning. */
         status = U_ZERO_ERROR;
         uregex_setText(re, text1, -1, &status);
         memset(buf, -1, sizeof(buf));
         resultSz = uregex_replaceFirst(re, replText, -1, buf, strlen("Replace <aa> x1x x...x."), &status);
         TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
@@ skipping 41 matching lines @@
         UChar    replText2[80];      /*  "<<$1>>"                  */
         const char * pattern = "x(.*?)x";
         const char * expectedResult = "Replace <aa> <1> <...>.";
         const char * expectedResult2 = "Replace <<aa>> <<1>> <<...>>.";
         UChar    buf[80];
         int32_t  resultSize;
         int32_t  expectedResultSize;
         int32_t  expectedResultSize2;
         int32_t  i;
 
-        u_uastrncpy(text1, "Replace xaax x1x x...x.",  sizeof(text1)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
-        u_uastrncpy(replText, "<$1>", sizeof(replText)/2);
-        u_uastrncpy(replText2, "<<$1>>", sizeof(replText2)/2);
+        u_uastrncpy(text1, "Replace xaax x1x x...x.",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
+        u_uastrncpy(replText, "<$1>", UPRV_LENGTHOF(replText));
+        u_uastrncpy(replText2, "<<$1>>", UPRV_LENGTHOF(replText2));
         expectedResultSize = strlen(expectedResult);
         expectedResultSize2 = strlen(expectedResult2);
 
         status = U_ZERO_ERROR;
         re = uregex_openC(pattern, 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /*  Normal case, with match */
         uregex_setText(re, text1, -1, &status);
-        resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
+        resultSize = uregex_replaceAll(re, replText, -1, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING(expectedResult, buf, TRUE);
         TEST_ASSERT(resultSize == expectedResultSize);
 
         /* No match.  Text should copy to output with no changes.  */
         status = U_ZERO_ERROR;
         uregex_setText(re, text2, -1, &status);
-        resultSize = uregex_replaceAll(re, replText, -1, buf, sizeof(buf)/2, &status);
+        resultSize = uregex_replaceAll(re, replText, -1, buf, UPRV_LENGTHOF(buf), &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("No match here.", buf, TRUE);
         TEST_ASSERT(resultSize == u_strlen(text2));
 
         /*  Match, output just fills buffer, no termination warning. */
         status = U_ZERO_ERROR;
         uregex_setText(re, text1, -1, &status);
         memset(buf, -1, sizeof(buf));
         resultSize = uregex_replaceAll(re, replText, -1, buf, expectedResultSize, &status);
         TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
@@ skipping 63 matching lines @@
         UChar    repl[100];
         UChar    buf[100];
         UChar   *bufPtr;
         int32_t  bufCap;
 
 
         status = U_ZERO_ERROR;
         re = uregex_openC(".*", 0, 0, &status);
         TEST_ASSERT_SUCCESS(status);
 
-        u_uastrncpy(text, "whatever",  sizeof(text)/2);
-        u_uastrncpy(repl, "some other", sizeof(repl)/2);
+        u_uastrncpy(text, "whatever",  UPRV_LENGTHOF(text));
+        u_uastrncpy(repl, "some other", UPRV_LENGTHOF(repl));
         uregex_setText(re, text, -1, &status);
 
         /* match covers whole target string */
         uregex_find(re, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         bufPtr = buf;
-        bufCap = sizeof(buf) / 2;
+        bufCap = UPRV_LENGTHOF(buf);
         uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("some other", buf, TRUE);
 
         /* Match has \u \U escapes */
         uregex_find(re, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         bufPtr = buf;
-        bufCap = sizeof(buf) / 2;
-        u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2);
+        bufCap = UPRV_LENGTHOF(buf);
+        u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", UPRV_LENGTHOF(repl));
         uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE); 
 
         /* Bug 6813, parameter check of NULL destCapacity; crashed before fix. */
         status = U_ZERO_ERROR;
         uregex_find(re, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         bufPtr = buf;
         status = U_BUFFER_OVERFLOW_ERROR;
@@ skipping 14 matching lines @@
     {
         UChar    textToSplit[80];
         UChar    text2[80];
         UChar    buf[200];
         UChar    *fields[10];
         int32_t  numFields;
         int32_t  requiredCapacity;
         int32_t  spaceNeeded;
         int32_t  sz;
 
-        u_uastrncpy(textToSplit, "first : second:  third",  sizeof(textToSplit)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
+        u_uastrncpy(textToSplit, "first : second:  third",  UPRV_LENGTHOF(textToSplit));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
 
         status = U_ZERO_ERROR;
         re = uregex_openC(":", 0, NULL, &status);
 
 
         /*  Simple split */ 
 
         uregex_setText(re, textToSplit, -1, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if (U_SUCCESS(status)) {
             memset(fields, -1, sizeof(fields));
             numFields = 
-                uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
+                uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 10, &status);
             TEST_ASSERT_SUCCESS(status);
 
             /* The TEST_ASSERT_SUCCESS call above should change too... */
             if(U_SUCCESS(status)) {
                 TEST_ASSERT(numFields == 3);
                 TEST_ASSERT_STRING("first ",  fields[0], TRUE);
                 TEST_ASSERT_STRING(" second", fields[1], TRUE);
                 TEST_ASSERT_STRING("  third", fields[2], TRUE);
                 TEST_ASSERT(fields[3] == NULL);
 
@@ skipping 11 matching lines @@
         /*  Split with too few output strings available */
         status = U_ZERO_ERROR;
         re = uregex_openC(":", 0, NULL, &status);
         uregex_setText(re, textToSplit, -1, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             memset(fields, -1, sizeof(fields));
             numFields = 
-                uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
+                uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 2, &status);
             TEST_ASSERT_SUCCESS(status);
 
             /* The TEST_ASSERT_SUCCESS call above should change too... */
             if(U_SUCCESS(status)) {
                 TEST_ASSERT(numFields == 2);
                 TEST_ASSERT_STRING("first ",  fields[0], TRUE);
                 TEST_ASSERT_STRING(" second:  third", fields[1], TRUE);
                 TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
 
                 spaceNeeded = u_strlen(textToSplit) -
@@ skipping 37 matching lines @@
      *                   comes out as additional fields.  */
     {
         UChar    textToSplit[80];
         UChar    buf[200];
         UChar    *fields[10];
         int32_t  numFields;
         int32_t  requiredCapacity;
         int32_t  spaceNeeded;
         int32_t  sz;
 
-        u_uastrncpy(textToSplit, "first <tag-a> second<tag-b>  third",  sizeof(textToSplit)/2);
+        u_uastrncpy(textToSplit, "first <tag-a> second<tag-b>  third",  UPRV_LENGTHOF(textToSplit));
 
         status = U_ZERO_ERROR;
         re = uregex_openC("<(.*?)>", 0, NULL, &status);
 
         uregex_setText(re, textToSplit, -1, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             memset(fields, -1, sizeof(fields));
             numFields = 
-                uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 10, &status);
+                uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 10, &status);
             TEST_ASSERT_SUCCESS(status);
 
             /* The TEST_ASSERT_SUCCESS call above should change too... */
             if(U_SUCCESS(status)) {
                 TEST_ASSERT(numFields == 5);
                 TEST_ASSERT_STRING("first ",  fields[0], TRUE);
                 TEST_ASSERT_STRING("tag-a",   fields[1], TRUE);
                 TEST_ASSERT_STRING(" second", fields[2], TRUE);
                 TEST_ASSERT_STRING("tag-b",   fields[3], TRUE);
                 TEST_ASSERT_STRING("  third", fields[4], TRUE);
                 TEST_ASSERT(fields[5] == NULL);
                 spaceNeeded = strlen("first .tag-a. second.tag-b.  third.");  /* "." at NUL positions */
                 TEST_ASSERT(spaceNeeded == requiredCapacity);
             }
         }
     
         /*  Split with too few output strings available (2) */
         status = U_ZERO_ERROR;
         memset(fields, -1, sizeof(fields));
         numFields = 
-            uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 2, &status);
+            uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 2, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             TEST_ASSERT(numFields == 2);
             TEST_ASSERT_STRING("first ",  fields[0], TRUE);
             TEST_ASSERT_STRING(" second<tag-b>  third", fields[1], TRUE);
             TEST_ASSERT(!memcmp(&fields[2],&minus1,sizeof(UChar*)));
 
             spaceNeeded = strlen("first . second<tag-b>  third.");  /* "." at NUL positions */
             TEST_ASSERT(spaceNeeded == requiredCapacity);
         }
 
         /*  Split with too few output strings available (3) */
         status = U_ZERO_ERROR;
         memset(fields, -1, sizeof(fields));
         numFields = 
-            uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 3, &status);
+            uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 3, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             TEST_ASSERT(numFields == 3);
             TEST_ASSERT_STRING("first ",  fields[0], TRUE);
             TEST_ASSERT_STRING("tag-a",   fields[1], TRUE);
             TEST_ASSERT_STRING(" second<tag-b>  third", fields[2], TRUE);
             TEST_ASSERT(!memcmp(&fields[3],&minus1,sizeof(UChar*)));
 
             spaceNeeded = strlen("first .tag-a. second<tag-b>  third.");  /* "." at NUL positions */
             TEST_ASSERT(spaceNeeded == requiredCapacity);
         }
 
         /*  Split with just enough output strings available (5) */
         status = U_ZERO_ERROR;
         memset(fields, -1, sizeof(fields));
         numFields = 
-            uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 5, &status);
+            uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 5, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             TEST_ASSERT(numFields == 5);
             TEST_ASSERT_STRING("first ",  fields[0], TRUE);
             TEST_ASSERT_STRING("tag-a",   fields[1], TRUE);
             TEST_ASSERT_STRING(" second", fields[2], TRUE);
             TEST_ASSERT_STRING("tag-b",   fields[3], TRUE);
             TEST_ASSERT_STRING("  third", fields[4], TRUE);
             TEST_ASSERT(!memcmp(&fields[5],&minus1,sizeof(UChar*)));
 
             spaceNeeded = strlen("first .tag-a. second.tag-b.  third.");  /* "." at NUL positions */
             TEST_ASSERT(spaceNeeded == requiredCapacity);
         }
 
         /* Split, end of text is a field delimiter.   */
         status = U_ZERO_ERROR;
         sz = strlen("first <tag-a> second<tag-b>");
         uregex_setText(re, textToSplit, sz, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             memset(fields, -1, sizeof(fields));
             numFields = 
-                uregex_split(re, buf, sizeof(buf)/2, &requiredCapacity, fields, 9, &status);
+                uregex_split(re, buf, UPRV_LENGTHOF(buf), &requiredCapacity, fields, 9, &status);
             TEST_ASSERT_SUCCESS(status);
 
             /* The TEST_ASSERT_SUCCESS call above should change too... */
             if(U_SUCCESS(status)) {
                 TEST_ASSERT(numFields == 5);
                 TEST_ASSERT_STRING("first ",  fields[0], TRUE);
                 TEST_ASSERT_STRING("tag-a",   fields[1], TRUE);
                 TEST_ASSERT_STRING(" second", fields[2], TRUE);
                 TEST_ASSERT_STRING("tag-b",   fields[3], TRUE);
                 TEST_ASSERT_STRING("",        fields[4], TRUE);
@@ skipping 186 matching lines @@
         clone2 = uregex_clone(re, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(clone2 != NULL);
         uregex_close(re);
 
         status = U_ZERO_ERROR;
         clone3 = uregex_clone(clone2, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(clone3 != NULL);
 
-        u_uastrncpy(testString1, "abcccd", sizeof(pat)/2);
-        u_uastrncpy(testString2, "xxxabcccd", sizeof(pat)/2);
+        u_uastrncpy(testString1, "abcccd", UPRV_LENGTHOF(pat));
+        u_uastrncpy(testString2, "xxxabcccd", UPRV_LENGTHOF(pat));
 
         status = U_ZERO_ERROR;
         uregex_setText(clone1, testString1, -1, &status);
         TEST_ASSERT_SUCCESS(status);
         result = uregex_lookingAt(clone1, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(result==TRUE);
         
         status = U_ZERO_ERROR;
         uregex_setText(clone2, testString2, -1, &status);
@@ skipping 13 matching lines @@
 
     /*
      *  pattern() and patternText()
      */
     {
         const UChar  *resultPat;
         int32_t       resultLen;
         UText        *resultText;
         const char str_hello[] = { 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00 }; /* hello */
         const char str_hel[] = { 0x68, 0x65, 0x6c, 0x00 }; /* hel */
-        u_uastrncpy(pat, "hello", sizeof(pat)/2); /* for comparison */
+        u_uastrncpy(pat, "hello", UPRV_LENGTHOF(pat)); /* for comparison */
         status = U_ZERO_ERROR;
         
         utext_openUTF8(&patternText, str_hello, -1, &status);
         re = uregex_open(pat, -1, 0, NULL, &status);
         resultPat = uregex_pattern(re, &resultLen, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS above should change too... */
         if (U_SUCCESS(status)) {
             TEST_ASSERT(resultLen == -1);
@@ skipping 82 matching lines @@
         UText  *resultText;
         const UChar   *result;
         int32_t  textLength;
         const char str_abcccd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x65, 0x00 }; /* abcccd */
         const char str_abcccxd[] = { 0x62, 0x63, 0x64, 0x64, 0x64, 0x79, 0x65, 0x00 }; /* abcccxd */
         const char str_abcd[] = { 0x62, 0x63, 0x64, 0x2b, 0x65, 0x00 }; /* abc*d */
 
 
         status = U_ZERO_ERROR;
         utext_openUTF8(&text1, str_abcccd, -1, &status);
-        u_uastrncpy(text2Chars, str_abcccxd, sizeof(text2)/2);
+        u_uastrncpy(text2Chars, str_abcccxd, UPRV_LENGTHOF(text2Chars));
         utext_openUChars(&text2, text2Chars, -1, &status);
         
         utext_openUTF8(&patternText, str_abcd, -1, &status);
         re = uregex_openUText(&patternText, 0, NULL, &status);
 
         /* First set a UText */
         uregex_setUText(re, &text1, &status);
         resultText = uregex_getUText(re, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT(resultText != &text1);
@@ skipping 75 matching lines @@
      *  lookingAt()    Used in setText test.
      */
 
 
     /*
      *  find(), findNext, start, end, reset
      */
     {
         UChar    text1[50];
         UBool    result;
-        u_uastrncpy(text1, "012rx5rx890rxrx...",  sizeof(text1)/2);
+        u_uastrncpy(text1, "012rx5rx890rxrx...",  UPRV_LENGTHOF(text1));
         status = U_ZERO_ERROR;
         re = uregex_openC("rx", 0, NULL, &status);
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_find(re, 0, &status);
         TEST_ASSERT(result == TRUE);
         TEST_ASSERT(uregex_start(re, 0, &status) == 3);
         TEST_ASSERT(uregex_end(re, 0, &status) == 5);
         TEST_ASSERT_SUCCESS(status);
 
@@ skipping 43 matching lines @@
      */
     {
         UChar    text1[80];
         UText   *actual;
         UBool    result;
 
         const char str_abcinteriordef[] = { 0x61, 0x62, 0x63, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x66, 0x00 }; /* abc interior def */
         const char str_interior[] = { 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x00 }; /* ' interior ' */
         
 
-        u_uastrncpy(text1, "noise abc interior def, and this is off the end",  sizeof(text1)/2);
+        u_uastrncpy(text1, "noise abc interior def, and this is off the end",  UPRV_LENGTHOF(text1));
 
         status = U_ZERO_ERROR;
         re = uregex_openC("abc(.*?)def", 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         uregex_setText(re, text1, -1, &status);
         result = uregex_find(re, 0, &status);
         TEST_ASSERT(result==TRUE);
 
         /*  Capture Group 0, the full match.  Should succeed.  */
@@ skipping 57 matching lines @@
         UChar    text1[80];
         UChar    text2[80];
         UText    replText = UTEXT_INITIALIZER;
         UText   *result;
         const char str_Replxxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2e, 0x78, 0x2e, 0x00 }; /* Replace <aa> x1x x...x. */
         const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
         const char str_u00411U00000042a[] =  { 0x5c, 0x5c, 0x5c, 0x75, 0x30, 0x30, 0x34, 0x31, 0x24, 0x31, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x32, 0x24, 0x5c, 0x61, 0x00 }; /* \\\u0041$1\U00000042$\a */
         const char str_1x[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
         const char str_ReplaceAaaBax1xxx[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x5c, 0x41, 0x61, 0x61, 0x42, 0x24, 0x61, 0x20, 0x78, 0x31, 0x78, 0x20, 0x78, 0x2e, 0x2e, 0x2e, 0x78, 0x2e, 0x00 }; /* Replace \AaaB$a x1x x...x. */
         status = U_ZERO_ERROR;
-        u_uastrncpy(text1, "Replace xaax x1x x...x.",  sizeof(text1)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
+        u_uastrncpy(text1, "Replace xaax x1x x...x.",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
         utext_openUTF8(&replText, str_1x, -1, &status);
 
         re = uregex_openC("x(.*?)x", 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /*  Normal case, with match */
         uregex_setText(re, text1, -1, &status);
         result = uregex_replaceFirstUText(re, &replText, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_UTEXT(str_Replxxx, result);
@@ skipping 24 matching lines @@
      */
     {
         UChar    text1[80];
         UChar    text2[80];
         UText    replText = UTEXT_INITIALIZER;
         UText   *result;
         const char str_1[] = { 0x3c, 0x24, 0x31, 0x3e, 0x00 }; /* <$1> */
         const char str_Replaceaa1[] = { 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3c, 0x61, 0x61, 0x3e, 0x20, 0x3c, 0x31, 0x3e, 0x20, 0x3c, 0x2e, 0x2e, 0x2e, 0x3e, 0x2e, 0x00 }; /* Replace <aa> <1> <...>. */
         const char str_Nomatchhere[] = { 0x4e, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x68, 0x65, 0x72, 0x65, 0x2e, 0x00 }; /* No match here. */
         status = U_ZERO_ERROR;
-        u_uastrncpy(text1, "Replace xaax x1x x...x.",  sizeof(text1)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
+        u_uastrncpy(text1, "Replace xaax x1x x...x.",  UPRV_LENGTHOF(text1));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
         utext_openUTF8(&replText, str_1, -1, &status);
 
         re = uregex_openC("x(.*?)x", 0, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /*  Normal case, with match */
         uregex_setText(re, text1, -1, &status);
         result = uregex_replaceAllUText(re, &replText, NULL, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_UTEXT(str_Replaceaa1, result);
@@ skipping 18 matching lines @@
         UChar    text[100];
         UChar    repl[100];
         UChar    buf[100];
         UChar   *bufPtr;
         int32_t  bufCap;
 
         status = U_ZERO_ERROR;
         re = uregex_openC(".*", 0, 0, &status);
         TEST_ASSERT_SUCCESS(status);
 
-        u_uastrncpy(text, "whatever",  sizeof(text)/2);
-        u_uastrncpy(repl, "some other", sizeof(repl)/2);
+        u_uastrncpy(text, "whatever",  UPRV_LENGTHOF(text));
+        u_uastrncpy(repl, "some other", UPRV_LENGTHOF(repl));
         uregex_setText(re, text, -1, &status);
 
         /* match covers whole target string */
         uregex_find(re, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         bufPtr = buf;
-        bufCap = sizeof(buf) / 2;
+        bufCap = UPRV_LENGTHOF(buf);
         uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("some other", buf, TRUE);
 
         /* Match has \u \U escapes */
         uregex_find(re, 0, &status);
         TEST_ASSERT_SUCCESS(status);
         bufPtr = buf;
-        bufCap = sizeof(buf) / 2;
-        u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", sizeof(repl)/2);
+        bufCap = UPRV_LENGTHOF(buf);
+        u_uastrncpy(repl, "abc\\u0041\\U00000042 \\\\ $ \\abc", UPRV_LENGTHOF(repl));
         uregex_appendReplacement(re, repl, -1, &bufPtr, &bufCap, &status);
         TEST_ASSERT_SUCCESS(status);
         TEST_ASSERT_STRING("abcAB \\ $ abc", buf, TRUE); 
 
         uregex_close(re);
     }
 
 
     /*
      *  appendReplacement(), appendTail() checked in replaceFirst(), replaceAll().
      */
 
     /*
      *  splitUText()
      */
     {
         UChar    textToSplit[80];
         UChar    text2[80];
         UText    *fields[10];
         int32_t  numFields;
         int32_t i;
 
-        u_uastrncpy(textToSplit, "first : second:  third",  sizeof(textToSplit)/2);
-        u_uastrncpy(text2, "No match here.",  sizeof(text2)/2);
+        u_uastrncpy(textToSplit, "first : second:  third",  UPRV_LENGTHOF(textToSplit));
+        u_uastrncpy(text2, "No match here.",  UPRV_LENGTHOF(text2));
 
         status = U_ZERO_ERROR;
         re = uregex_openC(":", 0, NULL, &status);
 
 
         /*  Simple split */ 
 
         uregex_setText(re, textToSplit, -1, &status);
         TEST_ASSERT_SUCCESS(status);
 
@@ skipping 54 matching lines @@
     }
 
     /* splitUText(), part 2.  Patterns with capture groups.  The capture group text
      *                   comes out as additional fields.  */
     {
         UChar    textToSplit[80];
         UText    *fields[10];
         int32_t  numFields;
         int32_t i;
 
-        u_uastrncpy(textToSplit, "first <tag-a> second<tag-b>  third",  sizeof(textToSplit)/2);
+        u_uastrncpy(textToSplit, "first <tag-a> second<tag-b>  third",  UPRV_LENGTHOF(textToSplit));
 
         status = U_ZERO_ERROR;
         re = uregex_openC("<(.*?)>", 0, NULL, &status);
 
         uregex_setText(re, textToSplit, -1, &status);
         TEST_ASSERT_SUCCESS(status);
 
         /* The TEST_ASSERT_SUCCESS call above should change too... */
         if(U_SUCCESS(status)) {
             memset(fields, 0, sizeof(fields));
@@ skipping 202 matching lines @@
 
     uregex_setTimeLimit(re, 100, &status);
     TEST_ASSERT_SUCCESS(status);
     limit = uregex_getTimeLimit(re, &status);
     TEST_ASSERT_SUCCESS(status);
     TEST_ASSERT(limit == 100);
 
     uregex_close(re);
 }
 
+static UBool U_CALLCONV FindCallback(const void* context , int64_t matchIndex) {
+    return FALSE;
+}
+
+static UBool U_CALLCONV MatchCallback(const void *context, int32_t steps) {
+    return FALSE;
+}
+
+static void TestBug10815() {
+  /* Bug 10815:   uregex_findNext() does not set U_REGEX_STOPPED_BY_CALLER 
+   *              when the callback function specified by uregex_setMatchCallback() returns FALSE
+   */
+    URegularExpression *re;
+    UErrorCode status = U_ZERO_ERROR;
+    UChar    text[100];
+
+
+    // findNext() with a find progress callback function.
+
+    re = uregex_openC(".z", 0, 0, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    u_uastrncpy(text, "Hello, World.",  UPRV_LENGTHOF(text));
+    uregex_setText(re, text, -1, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    uregex_setFindProgressCallback(re, FindCallback, NULL, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    uregex_findNext(re, &status);
+    TEST_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
+
+    uregex_close(re);
+
+    // findNext() with a match progress callback function.
+
+    status = U_ZERO_ERROR;
+    re = uregex_openC("((xxx)*)*y", 0, 0, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    // Pattern + this text gives an exponential time match. Without the callback to stop the match,
+    // it will appear to be stuck in a (near) infinite loop.
+    u_uastrncpy(text, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  UPRV_LENGTHOF(text));
+    uregex_setText(re, text, -1, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    uregex_setMatchCallback(re, MatchCallback, NULL, &status);
+    TEST_ASSERT_SUCCESS(status);
+
+    uregex_findNext(re, &status);
+    TEST_ASSERT(status == U_REGEX_STOPPED_BY_CALLER);
+
+    uregex_close(re);
+}
+
     
 #endif   /*  !UCONFIG_NO_REGULAR_EXPRESSIONS */