ICU-66108.tar.gz

[apple/icu.git] / icuSources / test / cintltst / usrchtst.c

diff --git a/icuSources/test/cintltst/usrchtst.c b/icuSources/test/cintltst/usrchtst.c
index acd9b057c4fdc55e055d72aa96d9d03ebaa5dc69..5459d9e9faac55109aba11230046e28e4d1b4896 100644 (file)
--- a/icuSources/test/cintltst/usrchtst.c
+++ b/icuSources/test/cintltst/usrchtst.c
@@ -1,5 +1,7 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /********************************************************************
 /********************************************************************

- * Copyright (c) 2001-2011,2015 International Business Machines 
+ * Copyright (c) 2001-2016 International Business Machines

  * Corporation and others. All Rights Reserved.
  ********************************************************************
  * File usrchtst.c
  * Corporation and others. All Rights Reserved.
  ********************************************************************
  * File usrchtst.c


@@ -360,7 +362,7 @@ static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
         matchlength = search.size[count];
         usearch_next(strsrch, &status);
         if (matchindex != usearch_getMatchedStart(strsrch) || 
         matchlength = search.size[count];
         usearch_next(strsrch, &status);
         if (matchindex != usearch_getMatchedStart(strsrch) || 

-            matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
+            matchlength != usearch_getMatchedLength(strsrch)) {

             char *str = toCharString(usearch_getText(strsrch, &textlength));
             log_err("Text: %s\n", str);
             str = toCharString(usearch_getPattern(strsrch, &textlength));
             char *str = toCharString(usearch_getText(strsrch, &textlength));
             log_err("Text: %s\n", str);
             str = toCharString(usearch_getPattern(strsrch, &textlength));


@@ -373,7 +375,7 @@ static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
         count ++;
         
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
         count ++;
         
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=

-            (int32_t) matchlength || U_FAILURE(status) ||
+             matchlength || U_FAILURE(status) ||

             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0) {
             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0) {


@@ -402,7 +404,7 @@ static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
         matchlength = search.size[count];
         usearch_previous(strsrch, &status);
         if (matchindex != usearch_getMatchedStart(strsrch) || 
         matchlength = search.size[count];
         usearch_previous(strsrch, &status);
         if (matchindex != usearch_getMatchedStart(strsrch) || 

-            matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
+            matchlength != usearch_getMatchedLength(strsrch)) {

             char *str = toCharString(usearch_getText(strsrch, &textlength));
             log_err("Text: %s\n", str);
             str = toCharString(usearch_getPattern(strsrch, &textlength));
             char *str = toCharString(usearch_getText(strsrch, &textlength));
             log_err("Text: %s\n", str);
             str = toCharString(usearch_getPattern(strsrch, &textlength));


@@ -414,7 +416,7 @@ static UBool assertEqualWithUStringSearch(      UStringSearch *strsrch,
         }
         
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
         }
         
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=

-            (int32_t) matchlength || U_FAILURE(status) ||
+             matchlength || U_FAILURE(status) ||

             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0) {
             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0) {


@@ -1253,10 +1255,10 @@ static void TestGetSetOffset(void)
         ucol_setStrength(usearch_getCollator(strsrch), search.strength);
         usearch_reset(strsrch);
         while (U_SUCCESS(status) && matchindex >= 0) {
         ucol_setStrength(usearch_getCollator(strsrch), search.strength);
         usearch_reset(strsrch);
         while (U_SUCCESS(status) && matchindex >= 0) {

-            uint32_t matchlength = search.size[count];
+            int32_t matchlength = search.size[count];

             usearch_next(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 
             usearch_next(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 

-                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
+                matchlength != usearch_getMatchedLength(strsrch)) {

                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);
                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);


@@ -1270,7 +1272,7 @@ static void TestGetSetOffset(void)
             usearch_setOffset(strsrch, matchindex + matchlength, &status);
             usearch_previous(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 
             usearch_setOffset(strsrch, matchindex + matchlength, &status);
             usearch_previous(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 

-                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
+                matchlength != usearch_getMatchedLength(strsrch)) {

                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);
                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);


@@ -1457,23 +1459,23 @@ static void TestGetMatch(void)
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, NULL, 0, &status) != 
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, NULL, 0, &status) != 

-            (int32_t)matchlength || U_SUCCESS(status)){
+            matchlength || U_SUCCESS(status)){

             log_err("Error pre-flighting match length\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, 0, &status) != 
             log_err("Error pre-flighting match length\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, 0, &status) != 

-            (int32_t)matchlength || U_SUCCESS(status)){
+            matchlength || U_SUCCESS(status)){

             log_err("Error getting match text with buffer size 0\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, matchlength, &status) 
             log_err("Error getting match text with buffer size 0\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, matchlength, &status) 

-            != (int32_t)matchlength || matchtext[matchlength - 1] == 0 ||
+            != matchlength || matchtext[matchlength - 1] == 0 ||

             U_FAILURE(status)){
             log_err("Error getting match text with exact size\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=
             U_FAILURE(status)){
             log_err("Error getting match text with exact size\n");
         }
         status = U_ZERO_ERROR;
         if (usearch_getMatchedText(strsrch, matchtext, 128, &status) !=

-            (int32_t) matchlength || U_FAILURE(status) ||
+            matchlength || U_FAILURE(status) ||

             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0 ||
             memcmp(matchtext, 
                    usearch_getText(strsrch, &textlength) + matchindex,
                    matchlength * sizeof(UChar)) != 0 ||


@@ -2311,10 +2313,10 @@ static void TestGetSetOffsetCanonical(void)
         usearch_setText(strsrch, text, -1, &status);
         usearch_setPattern(strsrch, pattern, -1, &status);
         while (U_SUCCESS(status) && matchindex >= 0) {
         usearch_setText(strsrch, text, -1, &status);
         usearch_setPattern(strsrch, pattern, -1, &status);
         while (U_SUCCESS(status) && matchindex >= 0) {

-            uint32_t matchlength = search.size[count];
+            int32_t matchlength = search.size[count];

             usearch_next(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 
             usearch_next(strsrch, &status);
             if (matchindex != usearch_getMatchedStart(strsrch) || 

-                matchlength != (uint32_t)usearch_getMatchedLength(strsrch)) {
+                matchlength != usearch_getMatchedLength(strsrch)) {

                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);
                 char *str = toCharString(usearch_getText(strsrch, 
                                                          &textlength));
                 log_err("Text: %s\n", str);


@@ -2504,9 +2506,11 @@ exitTestForwardBackward :
     }
 }
 
     }
 }
 

-#define TEST_ASSERT(x) \
-   {if (U_FAILURE(x)) {log_err_status(x, "%s:%d: FAIL: test assertion failure \n", __FILE__, __LINE__);\
-   }}
+#define TEST_ASSERT(x) UPRV_BLOCK_MACRO_BEGIN { \
+    if (U_FAILURE(x)) { \
+        log_err_status(x, "%s:%d: FAIL: test assertion failure \n", __FILE__, __LINE__); \
+    } \
+} UPRV_BLOCK_MACRO_END

 
 static void TestSearchForNull(void) {
     UCollator *coll;
 
 static void TestSearchForNull(void) {
     UCollator *coll;


@@ -2604,8 +2608,8 @@ static void TestStrengthIdentical(void)
     
     UChar pattern[] = {0x05E9, 0x0591, 0x05E9};
     UChar text[]    = {0x05E9, 0x0592, 0x05E9};
     
     UChar pattern[] = {0x05E9, 0x0591, 0x05E9};
     UChar text[]    = {0x05E9, 0x0592, 0x05E9};

-    int32_t pLen = sizeof (pattern) / sizeof(pattern[0]);
-    int32_t tLen = sizeof(text) / sizeof (text[0]);
+    int32_t pLen = UPRV_LENGTHOF(pattern);
+    int32_t tLen = UPRV_LENGTHOF(text);

     int32_t expectedPos = 0;
     int32_t expectedLen = 3;
 
     int32_t expectedPos = 0;
     int32_t expectedLen = 3;
 


@@ -2656,12 +2660,11 @@ static void TestStrengthIdentical(void)
 * TestUsingSearchCollator
 */
 
 * TestUsingSearchCollator
 */
 

-#define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
-

 typedef struct {
     const UChar *   pattern;
     const int32_t * offsets;
     int32_t         offsetsLen;
 typedef struct {
     const UChar *   pattern;
     const int32_t * offsets;
     int32_t         offsetsLen;

+    const int32_t * matchLens;

 } PatternAndOffsets;
 
 static const UChar scKoText[] = {
 } PatternAndOffsets;
 
 static const UChar scKoText[] = {


@@ -2693,13 +2696,13 @@ static const int32_t scKoSrchOff23[] = { 5, 21, 25 };
 static const int32_t scKoSrchOff45[] = { 7, 30     };
 
 static const PatternAndOffsets scKoSrchPatternsOffsets[] = {
 static const int32_t scKoSrchOff45[] = { 7, 30     };
 
 static const PatternAndOffsets scKoSrchPatternsOffsets[] = {

-    { scKoPat0, scKoSrchOff01, ARRAY_LENGTH(scKoSrchOff01) },
-    { scKoPat1, scKoSrchOff01, ARRAY_LENGTH(scKoSrchOff01) },
-    { scKoPat2, scKoSrchOff23, ARRAY_LENGTH(scKoSrchOff23) },
-    { scKoPat3, scKoSrchOff23, ARRAY_LENGTH(scKoSrchOff23) },
-    { scKoPat4, scKoSrchOff45, ARRAY_LENGTH(scKoSrchOff45) },
-    { scKoPat5, scKoSrchOff45, ARRAY_LENGTH(scKoSrchOff45) },
-    { NULL,     NULL,          0                           }
+    { scKoPat0, scKoSrchOff01, UPRV_LENGTHOF(scKoSrchOff01), NULL },
+    { scKoPat1, scKoSrchOff01, UPRV_LENGTHOF(scKoSrchOff01), NULL },
+    { scKoPat2, scKoSrchOff23, UPRV_LENGTHOF(scKoSrchOff23), NULL },
+    { scKoPat3, scKoSrchOff23, UPRV_LENGTHOF(scKoSrchOff23), NULL },
+    { scKoPat4, scKoSrchOff45, UPRV_LENGTHOF(scKoSrchOff45), NULL },
+    { scKoPat5, scKoSrchOff45, UPRV_LENGTHOF(scKoSrchOff45), NULL },
+    { NULL,     NULL,          0,                            NULL }

 };
 
 static const int32_t scKoStndOff01[] = { 3,  9 };
 };
 
 static const int32_t scKoStndOff01[] = { 3,  9 };


@@ -2708,15 +2711,134 @@ static const int32_t scKoStndOff3[]  = { 25    };
 static const int32_t scKoStndOff45[] = { 7, 30 };
 
 static const PatternAndOffsets scKoStndPatternsOffsets[] = {
 static const int32_t scKoStndOff45[] = { 7, 30 };
 
 static const PatternAndOffsets scKoStndPatternsOffsets[] = {

-    { scKoPat0, scKoStndOff01, ARRAY_LENGTH(scKoStndOff01) },
-    { scKoPat1, scKoStndOff01, ARRAY_LENGTH(scKoStndOff01) },
-    { scKoPat2, scKoStndOff2,  ARRAY_LENGTH(scKoStndOff2)  },
-    { scKoPat3, scKoStndOff3,  ARRAY_LENGTH(scKoStndOff3)  },
-    { scKoPat4, scKoStndOff45, ARRAY_LENGTH(scKoStndOff45) },
-    { scKoPat5, scKoStndOff45, ARRAY_LENGTH(scKoStndOff45) },
-    { NULL,     NULL,          0                           }
+    { scKoPat0, scKoStndOff01, UPRV_LENGTHOF(scKoStndOff01), NULL },
+    { scKoPat1, scKoStndOff01, UPRV_LENGTHOF(scKoStndOff01), NULL },
+    { scKoPat2, scKoStndOff2,  UPRV_LENGTHOF(scKoStndOff2),  NULL  },
+    { scKoPat3, scKoStndOff3,  UPRV_LENGTHOF(scKoStndOff3),  NULL  },
+    { scKoPat4, scKoStndOff45, UPRV_LENGTHOF(scKoStndOff45), NULL },
+    { scKoPat5, scKoStndOff45, UPRV_LENGTHOF(scKoStndOff45), NULL },
+    { NULL,     NULL,          0,                            NULL }
+};
+
+static const UChar scJaText[] = {
+/*00*/ 0x304D,0x305F,0x0020,0x30AD,0x30BF,0x0020, /* kita, hiragana and katakana */
+/*06*/ 0x304D,0x3060,0x0020,0x30AD,0x30C0,0x0020, /* kida, hiragana and katakana */
+/*12*/ 0x306F,0x306D,0x0020,0x30CF,0x30CD,0x0020, /* hane, hiragana and katakana */
+/*18*/ 0x3070,0x306D,0x0020,0x30D0,0x30CD,0x0020, /* bane, hiragana and katakana */
+/*24*/ 0x3071,0x306D,0x0020,0x30D1,0x30CD,0x0020, /* pane, hiragana and katakana */
+/*30*/ 0
+};
+
+static const UChar scJaPatH0[] = { 0x304D,0x305F,0 }; /* kita, hiragana */
+static const UChar scJaPatK0[] = { 0x30AD,0x30BF,0 }; /* kita, katakana */
+static const UChar scJaPatH1[] = { 0x304D,0x3060,0 }; /* kida, hiragana */
+static const UChar scJaPatK1[] = { 0x30AD,0x30C0,0 }; /* kida, katakana */
+static const UChar scJaPatH2[] = { 0x306F,0x306D,0 }; /* hane, hiragana */
+static const UChar scJaPatK2[] = { 0x30CF,0x30CD,0 }; /* hane, katakana */
+static const UChar scJaPatH3[] = { 0x3070,0x306D,0 }; /* bane, hiragana */
+static const UChar scJaPatK3[] = { 0x30D0,0x30CD,0 }; /* bane, katakana */
+static const UChar scJaPatH4[] = { 0x3071,0x306D,0 }; /* pane, hiragana */
+static const UChar scJaPatK4[] = { 0x30D1,0x30CD,0 }; /* pane, katakana */
+
+static const int32_t scJaStndOff01[]  = { 0, 3, 6, 9 };
+static const int32_t scJaStndOff234[] = { 12, 15, 18, 21, 24, 27 };
+
+static const int32_t scJaSrchOff0[]  = { 0, 3 };
+static const int32_t scJaSrchOff1[]  = { 6, 9 };
+static const int32_t scJaSrchOff2[]  = { 12, 15 };
+static const int32_t scJaSrchOff3[]  = { 18, 21 };
+static const int32_t scJaSrchOff4[]  = { 24, 27 };
+
+static const PatternAndOffsets scJaStndPatternsOffsets[] = {
+    { scJaPatH0, scJaStndOff01,  UPRV_LENGTHOF(scJaStndOff01),  NULL },
+    { scJaPatK0, scJaStndOff01,  UPRV_LENGTHOF(scJaStndOff01),  NULL },
+    { scJaPatH1, scJaStndOff01,  UPRV_LENGTHOF(scJaStndOff01),  NULL },
+    { scJaPatK1, scJaStndOff01,  UPRV_LENGTHOF(scJaStndOff01),  NULL },
+    { scJaPatH2, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { scJaPatK2, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { scJaPatH3, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { scJaPatK3, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { scJaPatH4, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { scJaPatK4, scJaStndOff234, UPRV_LENGTHOF(scJaStndOff234), NULL },
+    { NULL,      NULL,           0,                             NULL }
+};
+
+static const PatternAndOffsets scJaSrchPatternsOffsets[] = {
+    { scJaPatH0, scJaSrchOff0,   UPRV_LENGTHOF(scJaSrchOff0), NULL },
+    { scJaPatK0, scJaSrchOff0,   UPRV_LENGTHOF(scJaSrchOff0), NULL },
+    { scJaPatH1, scJaSrchOff1,   UPRV_LENGTHOF(scJaSrchOff1), NULL },
+    { scJaPatK1, scJaSrchOff1,   UPRV_LENGTHOF(scJaSrchOff1), NULL },
+    { scJaPatH2, scJaSrchOff2,   UPRV_LENGTHOF(scJaSrchOff2), NULL },
+    { scJaPatK2, scJaSrchOff2,   UPRV_LENGTHOF(scJaSrchOff2), NULL },
+    { scJaPatH3, scJaSrchOff3,   UPRV_LENGTHOF(scJaSrchOff3), NULL },
+    { scJaPatK3, scJaSrchOff3,   UPRV_LENGTHOF(scJaSrchOff3), NULL },
+    { scJaPatH4, scJaSrchOff4,   UPRV_LENGTHOF(scJaSrchOff4), NULL },
+    { scJaPatK4, scJaSrchOff4,   UPRV_LENGTHOF(scJaSrchOff4), NULL },
+    { NULL,      NULL,           0,                           NULL }
+};
+
+static const UChar scFaText[] = { // Apple <rdar://problem/34998959>
+/*00*/ 0x064A,0x0627,0x0649,0x0627,0x06CC,0x0627,
+/*06*/ 0
+};
+
+// Any of the following should match any of the others for fa search, primary strength
+static const UChar scFaPat1[] = { 0x064A,0 };
+static const UChar scFaPat2[] = { 0x0649,0 };
+static const UChar scFaPat3[] = { 0x06CC,0 };
+
+static const int32_t scFaSrchOff[]  = { 0, 2, 4 };
+
+static const PatternAndOffsets scFaSrchPatternsOffsets[] = {
+    { scFaPat1, scFaSrchOff,   UPRV_LENGTHOF(scFaSrchOff), NULL },
+    { scFaPat2, scFaSrchOff,   UPRV_LENGTHOF(scFaSrchOff), NULL },
+    { scFaPat3, scFaSrchOff,   UPRV_LENGTHOF(scFaSrchOff), NULL },
+    { NULL,     NULL,          0,                          NULL }
+};
+
+static const UChar scModsText[] = {
+/*00*/ 0x0020,0xD83D,0xDC4D,
+/*03*/ 0x0020,0xD83D,0xDC4D,0xD83C,0xDFFC,
+/*08*/ 0x0020,0xD83D,0xDC4D,0xD83C,0xDFFF,
+/*13*/ 0x0020,0xD83D,0xDC4D,0x0300,
+/*17*/ 0x0020,0
+};
+
+static const UChar scMods0[] = { 0xD83D,0xDC4D,0 }; /* hand with no mods */
+static const UChar scMods1[] = { 0xD83D,0xDC4D,0xD83C,0xDFFC,0 }; /* hand with fitz 3 */
+static const UChar scMods2[] = { 0xD83D,0xDC4D,0xD83C,0xDFFF,0 }; /* hand with fitz 6 */
+static const UChar scMods3[] = { 0xD83D,0xDC4D,0x0300,0 }; /* hand with grave */
+
+static const int32_t scMods012[]  = { 1, 4, 9, 14 };
+static const int32_t scModsLens012[]  = { 2, 4, 4, 3 };
+
+static const PatternAndOffsets scModsPatternsOffsets[] = {
+    { scMods0,   scMods012,      UPRV_LENGTHOF(scMods012), scModsLens012 },
+    { scMods1,   scMods012,      UPRV_LENGTHOF(scMods012), scModsLens012 },
+    { scMods2,   scMods012,      UPRV_LENGTHOF(scMods012), scModsLens012 },
+    { scMods3,   scMods012,      UPRV_LENGTHOF(scMods012), scModsLens012 },
+    { NULL,      NULL,           0,                        NULL }
+};
+
+static const UChar scFlagText[] = {
+/*00*/ 0xD83C,0xDDF3,0xD83C,0xDDFF, /*NZ*/
+/*04*/ 0xD83C,0xDFF4,0xDB40,0xDC67,0xDB40,0xDC62,0xDB40,0xDC65,0xDB40,0xDC6E,0xDB40,0xDC67,0xDB40,0xDC7F, /*gbeng*/
+/*18*/ 0x0061,0x0062,0x0063,
+/*21*/ 0xD83C,0xDFF4,0xDB40,0xDC67,0xDB40,0xDC62,0xDB40,0xDC73,0xDB40,0xDC63,0xDB40,0xDC74,0xDB40,0xDC7F, /*gbsct*/
+/*35*/ 0xD83C,0xDFF4,0xDB40,0xDC67,0xDB40,0xDC62,0xDB40,0xDC77,0xDB40,0xDC6C,0xDB40,0xDC73,0xDB40,0xDC7F, /*gbwls*/
+/*49*/ 0x0020,0
+};
+
+static const UChar scFlag1[] = { 0xD83C,0xDFF4,0xDB40,0xDC67,0xDB40,0xDC62,0xDB40,0xDC73,0xDB40,0xDC63,0xDB40,0xDC74,0xDB40,0xDC7F,0 }; /* gbsct */
+static const int32_t scOffFlag1[]  = { 21 };
+static const int32_t scLenFlag1[]  = { 14 };
+
+static const PatternAndOffsets scFlagPatternsOffsets[] = {
+    { scFlag1,   scOffFlag1,   UPRV_LENGTHOF(scOffFlag1),   scLenFlag1 },
+    { NULL,      NULL,         0,                           NULL }

 };
 
 };
 

+

 typedef struct {
     const char *  locale;
     const UChar * text;
 typedef struct {
     const char *  locale;
     const UChar * text;


@@ -2727,6 +2849,13 @@ static const TUSCItem tuscItems[] = {
     { "root",                  scKoText, scKoStndPatternsOffsets },
     { "root@collation=search", scKoText, scKoSrchPatternsOffsets },
     { "ko@collation=search",   scKoText, scKoSrchPatternsOffsets },
     { "root",                  scKoText, scKoStndPatternsOffsets },
     { "root@collation=search", scKoText, scKoSrchPatternsOffsets },
     { "ko@collation=search",   scKoText, scKoSrchPatternsOffsets },

+    { "root@colStrength=primary",                  scJaText, scJaStndPatternsOffsets },
+    { "root@collation=search;colStrength=primary", scJaText, scJaSrchPatternsOffsets },
+    { "ja@colStrength=primary",                    scJaText, scJaStndPatternsOffsets },
+    { "ja@collation=search;colStrength=primary",   scJaText, scJaSrchPatternsOffsets },
+    { "fa@collation=search;colStrength=primary",   scFaText, scFaSrchPatternsOffsets }, // Apple <rdar://problem/34998959>
+    { "root@collation=search;colStrength=primary", scModsText, scModsPatternsOffsets },
+    { "root@collation=search;colStrength=primary", scFlagText, scFlagPatternsOffsets },

     { NULL,                    NULL,     NULL                    }
 };
 
     { NULL,                    NULL,     NULL                    }
 };
 


@@ -2743,35 +2872,49 @@ static void TestUsingSearchCollator(void)
             if ( U_SUCCESS(status) ) {
                 const PatternAndOffsets * patternsOffsetsPtr;
                 for ( patternsOffsetsPtr = tuscItemPtr->patternsAndOffsets; patternsOffsetsPtr->pattern != NULL; patternsOffsetsPtr++) {
             if ( U_SUCCESS(status) ) {
                 const PatternAndOffsets * patternsOffsetsPtr;
                 for ( patternsOffsetsPtr = tuscItemPtr->patternsAndOffsets; patternsOffsetsPtr->pattern != NULL; patternsOffsetsPtr++) {

-                    usearch_setPattern(usrch, patternsOffsetsPtr->pattern, -1, &status);
+                    int32_t patLen = u_strlen(patternsOffsetsPtr->pattern);
+                    usearch_setPattern(usrch, patternsOffsetsPtr->pattern, patLen, &status);

                     if ( U_SUCCESS(status) ) {
                         int32_t offset;
                         const int32_t * nextOffsetPtr;
                         const int32_t * limitOffsetPtr;
                     if ( U_SUCCESS(status) ) {
                         int32_t offset;
                         const int32_t * nextOffsetPtr;
                         const int32_t * limitOffsetPtr;

+                        const int32_t * nextMatchLenPtr;

 
                         usearch_reset(usrch);
                         nextOffsetPtr = patternsOffsetsPtr->offsets;
                         limitOffsetPtr = patternsOffsetsPtr->offsets + patternsOffsetsPtr->offsetsLen;
 
                         usearch_reset(usrch);
                         nextOffsetPtr = patternsOffsetsPtr->offsets;
                         limitOffsetPtr = patternsOffsetsPtr->offsets + patternsOffsetsPtr->offsetsLen;

+                        nextMatchLenPtr = patternsOffsetsPtr->matchLens;

                         while (TRUE) {
                             offset = usearch_next(usrch, &status);
                             if ( U_FAILURE(status) || offset == USEARCH_DONE ) {
                                 break;
                             }
                             if ( nextOffsetPtr < limitOffsetPtr ) {
                         while (TRUE) {
                             offset = usearch_next(usrch, &status);
                             if ( U_FAILURE(status) || offset == USEARCH_DONE ) {
                                 break;
                             }
                             if ( nextOffsetPtr < limitOffsetPtr ) {

-                                 if (offset != *nextOffsetPtr) {
-                                     log_err("error, locale %s, expected usearch_next %d, got %d\n", tuscItemPtr->locale, *nextOffsetPtr, offset);
-                                     nextOffsetPtr = limitOffsetPtr;
-                                     break;
-                                 }
-                                 nextOffsetPtr++;
+                                if (offset != *nextOffsetPtr) {
+                                    log_err("error, locale %s, patn (%d) %04X %04X..., expected usearch_next %d, got %d\n",
+                                             tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1], *nextOffsetPtr, offset);
+                                    nextOffsetPtr = limitOffsetPtr;
+                                    break;
+                                } else  if (nextMatchLenPtr != NULL) {
+                                    int32_t matchLen = usearch_getMatchedLength(usrch);
+                                    if (matchLen != *nextMatchLenPtr) {
+                                        log_err("error, locale %s, patn (%d) %04X %04X..., offset %d, expected matchLen %d, got %d\n",
+                                                tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1], offset, *nextMatchLenPtr, matchLen);
+                                    }
+                                    nextMatchLenPtr++;
+                                }
+                                nextOffsetPtr++;

                             } else {
                             } else {

-                                log_err("error, locale %s, usearch_next returned more matches than expected\n", tuscItemPtr->locale );
+                                log_err("error, locale %s, patn (%d) %04X %04X..., usearch_next returned more matches than expected\n",
+                                        tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1] );

                             }
                         }
                         if ( U_FAILURE(status) ) {
                             }
                         }
                         if ( U_FAILURE(status) ) {

-                            log_err("error, locale %s, usearch_next failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
+                            log_err("error, locale %s, patn (%d) %04X %04X..., usearch_next failed: %s\n",
+                                    tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1], u_errorName(status) );

                         } else if ( nextOffsetPtr < limitOffsetPtr ) {
                         } else if ( nextOffsetPtr < limitOffsetPtr ) {

-                            log_err("error, locale %s, usearch_next returned fewer matches than expected\n", tuscItemPtr->locale );
+                            log_err("error, locale %s, patn (%d) %04X %04X..., usearch_next returned fewer matches than expected\n",
+                                    tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1] );

                         }
 
                         status = U_ZERO_ERROR;
                         }
 
                         status = U_ZERO_ERROR;


@@ -2786,22 +2929,27 @@ static void TestUsingSearchCollator(void)
                             if ( nextOffsetPtr > limitOffsetPtr ) {
                                 nextOffsetPtr--;
                                 if (offset != *nextOffsetPtr) {
                             if ( nextOffsetPtr > limitOffsetPtr ) {
                                 nextOffsetPtr--;
                                 if (offset != *nextOffsetPtr) {

-                                     log_err("error, locale %s, expected usearch_previous %d, got %d\n", tuscItemPtr->locale, *nextOffsetPtr, offset);
-                                     nextOffsetPtr = limitOffsetPtr;
-                                      break;
+                                    log_err("error, locale %s, patn (%d) %04X %04X..., expected usearch_previous %d, got %d\n",
+                                            tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1], *nextOffsetPtr, offset);
+                                    nextOffsetPtr = limitOffsetPtr;
+                                    break;

                                 }
                             } else {
                                 }
                             } else {

-                                log_err("error, locale %s, usearch_previous returned more matches than expected\n", tuscItemPtr->locale );
+                                log_err("error, locale %s, patn (%d) %04X %04X..., usearch_previous returned more matches than expected\n",
+                                        tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1] );

                             }
                         }
                         if ( U_FAILURE(status) ) {
                             }
                         }
                         if ( U_FAILURE(status) ) {

-                            log_err("error, locale %s, usearch_previous failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
+                            log_err("error, locale %s, patn (%d) %04X %04X..., usearch_previous failed: %s\n", 
+                                    tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1], u_errorName(status) );

                         } else if ( nextOffsetPtr > limitOffsetPtr ) {
                         } else if ( nextOffsetPtr > limitOffsetPtr ) {

-                            log_err("error, locale %s, usearch_previous returned fewer matches than expected\n", tuscItemPtr->locale );
+                            log_err("error, locale %s, patn (%d) %04X %04X..., usearch_previous returned fewer matches than expected\n",
+                                    tuscItemPtr->locale, patLen, patternsOffsetsPtr->pattern[0], patternsOffsetsPtr->pattern[1] );

                         }
 
                     } else {
                         }
 
                     } else {

-                        log_err("error, locale %s, usearch_setPattern failed: %s\n", tuscItemPtr->locale, u_errorName(status) );
+                        log_err("error, locale %s, usearch_setPattern failed: %s\n",
+                                tuscItemPtr->locale, u_errorName(status) );

                     }
                 }
                 usearch_close(usrch);
                     }
                 }
                 usearch_close(usrch);


@@ -2892,14 +3040,51 @@ exit:
    return;
 }
 
    return;
 }
 

+static void TestUInt16Overflow(void) {
+    const int32_t uint16_overflow = UINT16_MAX + 1;
+    UChar* pattern = (UChar*)uprv_malloc(uint16_overflow * sizeof(UChar));
+    if (pattern == NULL)
+    {
+        log_err("Err: uprv_malloc returned NULL\n");
+        return;
+    }
+    u_memset(pattern, 'A', uint16_overflow);
+    UChar text[] = { 'B' };
+
+    UErrorCode errorCode = U_ZERO_ERROR;
+    UStringSearch* usearch = usearch_open(pattern, uint16_overflow, text, 1, "en-US", NULL, &errorCode);
+
+    if (U_SUCCESS(errorCode))
+    {
+        int32_t match = usearch_first(usearch, &errorCode);
+
+        if (U_SUCCESS(errorCode))
+        {
+            if (match != USEARCH_DONE)
+            {
+                log_err("Err: match was not expected, got %d\n", match);
+            }
+        }
+        else
+        {
+            log_err("usearch_first error %s\n", u_errorName(errorCode));
+        }
+        usearch_close(usearch);
+    }
+    else
+    {
+        log_err("usearch_open error %s\n", u_errorName(errorCode));
+    }
+    uprv_free(pattern);
+}

 
 static void TestPCEBuffer_100df(void) {
   UChar search[] =
     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df }; /* 38 cp, 9 of them unpaired surrogates */
   UChar source[] = 
     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df };
 
 static void TestPCEBuffer_100df(void) {
   UChar search[] =
     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df }; /* 38 cp, 9 of them unpaired surrogates */
   UChar source[] = 
     { 0x0020, 0x0020, 0x00df, 0x0020, 0x0041, 0x00df, 0x0020, 0x0061, 0x00df, 0x0020, 0x00c5, 0x00df, 0x0020, 0x212b, 0x00df, 0x0020, 0x0041, 0x030a, 0x00df, 0x0020, 0x00e5, 0x00df, 0x0020, 0x0061, 0x02da, 0x00df, 0x0020, 0x0061, 0x030a, 0x00df, 0x0020, 0xd8fa, 0xdeae, 0x00df, 0x0020, 0x2027, 0x00df };

-  uint32_t searchLen = sizeof(search)/sizeof(UChar);
-  uint32_t sourceLen = sizeof(source)/sizeof(UChar);
+  uint32_t searchLen = UPRV_LENGTHOF(search);
+  uint32_t sourceLen = UPRV_LENGTHOF(source);

   TestPCEBuffer_with(search,searchLen,source,sourceLen);
  }
 
   TestPCEBuffer_with(search,searchLen,source,sourceLen);
  }
 


@@ -2909,8 +3094,8 @@ static void TestPCEBuffer_2surr(void) {
     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff }; /* 38 cp, 9 of them unpaired surrogates */
   UChar source[] = 
     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff };
     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff }; /* 38 cp, 9 of them unpaired surrogates */
   UChar source[] = 
     { 0x0020, 0x0020, 0xdfff, 0x0020, 0x0041, 0xdfff, 0x0020, 0x0061, 0xdfff, 0x0020, 0x00c5, 0xdfff, 0x0020, 0x212b, 0xdfff, 0x0020, 0x0041, 0x030a, 0xdfff, 0x0020, 0x00e5, 0xdfff, 0x0020, 0x0061, 0x02da, 0xdfff, 0x0020, 0x0061, 0x030a, 0xdfff, 0x0020, 0xd8fa, 0xdeae, 0xdfff, 0x0020, 0x2027, 0xdfff };

-  uint32_t searchLen = sizeof(search)/sizeof(UChar);
-  uint32_t sourceLen = sizeof(source)/sizeof(UChar);
+  uint32_t searchLen = UPRV_LENGTHOF(search);
+  uint32_t sourceLen = UPRV_LENGTHOF(source);

   TestPCEBuffer_with(search,searchLen,source,sourceLen);
 }
 
   TestPCEBuffer_with(search,searchLen,source,sourceLen);
 }
 


@@ -2929,8 +3114,8 @@ static void TestMatchFollowedByIgnorables(void) {
     int32_t matchLength = 0;
     const int32_t expectedMatchLength = 1;
 
     int32_t matchLength = 0;
     const int32_t expectedMatchLength = 1;
 

-    searchLen = sizeof(search)/sizeof(UChar);
-    sourceLen = sizeof(source)/sizeof(UChar);
+    searchLen = UPRV_LENGTHOF(search);
+    sourceLen = UPRV_LENGTHOF(source);

 
     coll = ucol_openFromShortString("LHR_AN_CX_EX_FX_HX_NX_S3",
                                     FALSE,
 
     coll = ucol_openFromShortString("LHR_AN_CX_EX_FX_HX_NX_S3",
                                     FALSE,


@@ -2987,7 +3172,7 @@ static void TestMatchFollowedByIgnorables(void) {
     ucol_close(coll);
 }
 
     ucol_close(coll);
 }
 

-static void TestIndicPrefixMatch(void) // <rdar://problem/18063262>
+static void TestIndicPrefixMatch(void)

 {
     int count = 0;
     UErrorCode status = U_ZERO_ERROR;
 {
     int count = 0;
     UErrorCode status = U_ZERO_ERROR;


@@ -3068,6 +3253,7 @@ void addSearchTest(TestNode** root)
     addTest(root, &TestPCEBuffer_2surr, "tscoll/usrchtst/TestPCEBuffer/2_dfff");
     addTest(root, &TestMatchFollowedByIgnorables, "tscoll/usrchtst/TestMatchFollowedByIgnorables");
     addTest(root, &TestIndicPrefixMatch, "tscoll/usrchtst/TestIndicPrefixMatch");
     addTest(root, &TestPCEBuffer_2surr, "tscoll/usrchtst/TestPCEBuffer/2_dfff");
     addTest(root, &TestMatchFollowedByIgnorables, "tscoll/usrchtst/TestMatchFollowedByIgnorables");
     addTest(root, &TestIndicPrefixMatch, "tscoll/usrchtst/TestIndicPrefixMatch");

+    addTest(root, &TestUInt16Overflow, "tscoll/usrchtst/TestUInt16Overflow");

 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */