Update ICU to 54.1 step 1

source/test/intltest/utxttest.cpp

 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 2005-2012, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 2005-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /************************************************************************
 *   Tests for the UText and UTextIterator text abstraction classses
 *
 ************************************************************************/
 
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 36 matching lines @@
         case 0: name = "TextTest";
             if (exec) TextTest();    break;
         case 1: name = "ErrorTest";
             if (exec) ErrorTest();   break;
         case 2: name = "FreezeTest";
             if (exec) FreezeTest();  break;
         case 3: name = "Ticket5560";
             if (exec) Ticket5560();  break;
         case 4: name = "Ticket6847";
             if (exec) Ticket6847();  break;
+        case 5: name = "Ticket10562";
+            if (exec) Ticket10562();  break;
+        case 6: name = "Ticket10983";
+            if (exec) Ticket10983();  break;
         default: name = "";          break;
     }
 }
 
 //
 // Quick and dirty random number generator.
 //   (don't use library so that results are portable.
 static uint32_t m_seed = 1;
 static uint32_t m_rand()
 {
@@ skipping 49 matching lines @@
     //   Exercise the mapping, and the varying sized buffer.
     //
     s.truncate(0);
     UChar32  c1 = 0;
     UChar32  c2 = 0x100;
     UChar32  c3 = 0xa000;
     UChar32  c4 = 0x11000;
     for (i=0; i<1000; i++) {
         int len8 = m_rand()%4 + 1;
         switch (len8) {
-            case 1: 
+            case 1:
                 c1 = (c1+1)%0x80;
                 // don't put 0 into string (0 terminated strings for some tests)
                 // don't put '\', will cause unescape() to fail.
                 if (c1==0x5c || c1==0) {
                     c1++;
                 }
                 s.append(c1);
                 break;
             case 2:
                 s.append(c2++);
@@ skipping 31 matching lines @@
     //
     m *cpMap = new m[sa.length() + 1];
     j = 0;
     for (i=0; i<sa.length(); i=sa.moveIndex32(i, 1)) {
         c = sa.char32At(i);
         cpMap[j].nativeIdx = i;
         cpMap[j].cp = c;
         j++;
         cpCount++;
     }
-    cpMap[j].nativeIdx = i;   // position following the last char in utf-16 string.    
+    cpMap[j].nativeIdx = i;   // position following the last char in utf-16 string.
 
 
     // UChar * test, null terminated
     status = U_ZERO_ERROR;
     UChar *buf = new UChar[saLen+1];
     sa.extract(buf, saLen+1, status);
     TEST_SUCCESS(status);
     ut = utext_openUChars(NULL, buf, -1, &status);
     TEST_SUCCESS(status);
     TestAccess(sa, ut, cpCount, cpMap);
@@ skipping 40 matching lines @@
     // Character Iterator Tests
     status = U_ZERO_ERROR;
     const UChar *cbuf = sa.getBuffer();
     CharacterIterator *ci = new UCharCharacterIterator(cbuf, saLen, status);
     TEST_SUCCESS(status);
     ut = utext_openCharacterIterator(NULL, ci, &status);
     TEST_SUCCESS(status);
     TestAccess(sa, ut, cpCount, cpMap);
     utext_close(ut);
     delete ci;
-    
+
 
     // Fragmented UnicodeString  (Chunk size of one)
     //
     status = U_ZERO_ERROR;
     ut = openFragmentedUnicodeString(NULL, &sa, &status);
     TEST_SUCCESS(status);
     TestAccess(sa, ut, cpCount, cpMap);
     utext_close(ut);
 
     //
@@ skipping 31 matching lines @@
 
 //  TestCMR   test Copy, Move and Replace operations.
 //              us         UnicodeString containing the test text.
 //              ut         UText containing the same test text.
 //              cpCount    number of code points in the test text.
 //              nativeMap  Mapping from code points to native indexes for the UText.
 //              u16Map     Mapping from code points to UTF-16 indexes, for use with the UnicodeString.
 //
 //     This function runs a whole series of opertions on each incoming UText.
 //     The UText is deep-cloned prior to each operation, so that the original UText remains unchanged.
-//     
+//
 void UTextTest::TestCMR(const UnicodeString &us, UText *ut, int cpCount, m *nativeMap, m *u16Map) {
     TEST_ASSERT(utext_isWritable(ut) == TRUE);
 
     int  srcLengthType;       // Loop variables for selecting the postion and length
     int  srcPosType;          //   of the block to operate on within the source text.
-    int  destPosType; 
+    int  destPosType;
 
     int  srcIndex  = 0;       // Code Point indexes of the block to operate on for
     int  srcLength = 0;       //   a specific test.
 
     int  destIndex = 0;       // Code point index of the destination for a copy/move test.
 
     int32_t  nativeStart = 0; // Native unit indexes for a test.
     int32_t  nativeLimit = 0;
     int32_t  nativeDest  = 0;
 
@@ skipping 12 matching lines @@
         }
         for (srcPosType=1; srcPosType<=5; srcPosType++) {
             switch (srcPosType) {
                 case 1: srcIndex = 0; break;
                 case 2: srcIndex = 1; break;
                 case 3: srcIndex = cpCount - srcLength; break;
                 case 4: srcIndex = cpCount - srcLength - 1; break;
                 case 5: srcIndex = cpCount / 2; break;
             }
             if (srcIndex < 0 || srcIndex + srcLength > cpCount) {
-                // filter out bogus test cases - 
+                // filter out bogus test cases -
                 //   those with a source range that falls of an edge of the string.
                 continue;
             }
 
             //
             // Copy and move tests.
             //   iterate over a variety of destination positions.
             //
             for (destPosType=1; destPosType<=4; destPosType++) {
                 switch (destPosType) {
@@ skipping 50 matching lines @@
     }
 
 }
 
 //
 //   TestCopyMove    run a single test case for utext_copy.
 //                   Test cases are created in TestCMR and dispatched here for execution.
 //
 void UTextTest::TestCopyMove(const UnicodeString &us, UText *ut, UBool move,
                     int32_t nativeStart, int32_t nativeLimit, int32_t nativeDest,
-                    int32_t u16Start, int32_t u16Limit, int32_t u16Dest) 
+                    int32_t u16Start, int32_t u16Limit, int32_t u16Dest)
 {
     UErrorCode      status   = U_ZERO_ERROR;
     UText          *targetUT = NULL;
     gTestNum++;
     gFailed = FALSE;
 
     //
     //  clone the UText.  The test will be run in the cloned copy
     //  so that we don't alter the original.
     //
@@ skipping 16 matching lines @@
     // Do the same operation in the UText under test
     utext_copy(targetUT, nativeStart, nativeLimit, nativeDest, move, &status);
     if (nativeDest > nativeStart && nativeDest < nativeLimit) {
         TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR);
     } else {
         TEST_SUCCESS(status);
 
         // Compare the results of the two parallel tests
         int32_t  usi = 0;    // UnicodeString postion, utf-16 index.
         int64_t  uti = 0;    // UText position, native index.
-        int32_t  cpi;        // char32 position (code point index) 
+        int32_t  cpi;        // char32 position (code point index)
         UChar32  usc;        // code point from Unicode String
         UChar32  utc;        // code point from UText
         utext_setNativeIndex(targetUT, 0);
         for (cpi=0; ; cpi++) {
             usc = targetUS.char32At(usi);
             utc = utext_next32(targetUT);
             if (utc < 0) {
                 break;
             }
             TEST_ASSERT(uti == usi);
             TEST_ASSERT(utc == usc);
             usi = targetUS.moveIndex32(usi, 1);
             uti = utext_getNativeIndex(targetUT);
             if (gFailed) {
                 goto cleanupAndReturn;
             }
         }
         int64_t expectedNativeLength = utext_nativeLength(ut);
         if (move == FALSE) {
             expectedNativeLength += nativeLimit - nativeStart;
         }
         uti = utext_getNativeIndex(targetUT);
         TEST_ASSERT(uti == expectedNativeLength);
     }
 
 cleanupAndReturn:
     utext_close(targetUT);
 }
-    
+
 
 //
 //  TestReplace   Test a single Replace operation.
 //
 void UTextTest::TestReplace(
-            const UnicodeString &us,     // reference UnicodeString in which to do the replace 
+            const UnicodeString &us,     // reference UnicodeString in which to do the replace
             UText         *ut,                // UnicodeText object under test.
-            int32_t       nativeStart,        // Range to be replaced, in UText native units. 
+            int32_t       nativeStart,        // Range to be replaced, in UText native units.
             int32_t       nativeLimit,
             int32_t       u16Start,           // Range to be replaced, in UTF-16 units
             int32_t       u16Limit,           //    for use in the reference UnicodeString.
             const UnicodeString &repStr)      // The replacement string
 {
     UErrorCode      status   = U_ZERO_ERROR;
     UText          *targetUT = NULL;
     gTestNum++;
     gFailed = FALSE;
 
     //
     //  clone the target UText.  The test will be run in the cloned copy
     //  so that we don't alter the original.
     //
     targetUT = utext_clone(NULL, ut, TRUE, FALSE, &status);
     TEST_SUCCESS(status);
     UnicodeString targetUS(us);    // And copy the reference string.
 
     //
-    // Do the replace operation in the Unicode String, to 
+    // Do the replace operation in the Unicode String, to
     //   produce a reference result.
     //
     targetUS.replace(u16Start, u16Limit-u16Start, repStr);
 
     //
     // Do the replace on the UText under test
     //
     const UChar *rs = repStr.getBuffer();
     int32_t  rsLen = repStr.length();
     int32_t actualDelta = utext_replace(targetUT, nativeStart, nativeLimit, rs, rsLen, &status);
     int32_t expectedDelta = repStr.length() - (nativeLimit - nativeStart);
     TEST_ASSERT(actualDelta == expectedDelta);
 
     //
     // Compare the results
     //
     int32_t  usi = 0;    // UnicodeString postion, utf-16 index.
     int64_t  uti = 0;    // UText position, native index.
-    int32_t  cpi;        // char32 position (code point index) 
+    int32_t  cpi;        // char32 position (code point index)
     UChar32  usc;        // code point from Unicode String
     UChar32  utc;        // code point from UText
     int64_t  expectedNativeLength = 0;
     utext_setNativeIndex(targetUT, 0);
     for (cpi=0; ; cpi++) {
         usc = targetUS.char32At(usi);
         utc = utext_next32(targetUT);
         if (utc < 0) {
             break;
         }
@@ skipping 37 matching lines @@
     status = U_ZERO_ERROR;
     utext_setNativeIndex(shallowClone, 0);
     UText *deepClone = utext_clone(NULL, shallowClone, TRUE, FALSE, &status);
     utext_close(shallowClone);
     if (status != U_UNSUPPORTED_ERROR) {
         TEST_SUCCESS(status);
         TestAccessNoClone(us, deepClone, cpCount, cpMap);
     }
     utext_close(deepClone);
 }
-    
+
 
 //
 //  TestAccessNoClone()    Test the read only access functions on a UText.
 //                         The text is accessed in a variety of ways, and compared with
 //                         the reference UnicodeString.
 //
 void UTextTest::TestAccessNoClone(const UnicodeString &us, UText *ut, int cpCount, m *cpMap) {
     UErrorCode  status = U_ZERO_ERROR;
     gTestNum++;
 
@@ skipping 14 matching lines @@
     int64_t     foundIndex = 0;
     UChar32     expectedC;
     UChar32     foundC;
     int64_t     len;
 
     for (i=0; i<cpCount; i++) {
         expectedIndex = cpMap[i].nativeIdx;
         foundIndex    = utext_getNativeIndex(ut);
         TEST_ASSERT(expectedIndex == foundIndex);
         expectedC     = cpMap[i].cp;
-        foundC        = utext_next32(ut);    
+        foundC        = utext_next32(ut);
         TEST_ASSERT(expectedC == foundC);
         foundIndex    = utext_getPreviousNativeIndex(ut);
         TEST_ASSERT(expectedIndex == foundIndex);
         if (gFailed) {
             return;
         }
     }
     foundC = utext_next32(ut);
     TEST_ASSERT(foundC == U_SENTINEL);
-    
+
     // Repeat above, using macros
     utext_setNativeIndex(ut, 0);
     for (i=0; i<cpCount; i++) {
         expectedIndex = cpMap[i].nativeIdx;
         foundIndex    = UTEXT_GETNATIVEINDEX(ut);
         TEST_ASSERT(expectedIndex == foundIndex);
         expectedC     = cpMap[i].cp;
-        foundC        = UTEXT_NEXT32(ut);    
+        foundC        = UTEXT_NEXT32(ut);
         TEST_ASSERT(expectedC == foundC);
         if (gFailed) {
             return;
         }
     }
     foundC = UTEXT_NEXT32(ut);
     TEST_ASSERT(foundC == U_SENTINEL);
 
     //
     //  Forward iteration (above) should have left index at the
@@ skipping 191 matching lines @@
             TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR);
         }
     }
 
     delete []buf;
 }
 
 //
 //  ErrorTest()    Check various error and edge cases.
 //
-void UTextTest::ErrorTest() 
+void UTextTest::ErrorTest()
 {
     // Close of an unitialized UText.  Shouldn't blow up.
     {
-        UText  ut;  
+        UText  ut;
         memset(&ut, 0, sizeof(UText));
         utext_close(&ut);
         utext_close(NULL);
     }
 
     // Double-close of a UText.  Shouldn't blow up.  UText should still be usable.
     {
         UErrorCode status = U_ZERO_ERROR;
         UText ut = UTEXT_INITIALIZER;
         UnicodeString s("Hello, World");
@@ skipping 44 matching lines @@
         utp = utext_openUnicodeString(&ut, &s1, &status);
         TEST_SUCCESS(status);
         TEST_ASSERT(utp == &ut);
     }
 
     // Invalid parameters on open
     //
     {
         UErrorCode status = U_ZERO_ERROR;
         UText ut = UTEXT_INITIALIZER;
-        
+
         utext_openUChars(&ut, NULL, 5, &status);
         TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
 
         status = U_ZERO_ERROR;
         utext_openUChars(&ut, NULL, -1, &status);
         TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
 
         status = U_ZERO_ERROR;
         utext_openUTF8(&ut, NULL, 4, &status);
         TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
 
         status = U_ZERO_ERROR;
         utext_openUTF8(&ut, NULL, -1, &status);
         TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR);
     }
 
     //
     //  UTF-8 with malformed sequences.
     //    These should come through as the Unicode replacement char, \ufffd
     //
     {
         UErrorCode status = U_ZERO_ERROR;
         UText *ut = NULL;
-        const char *badUTF8 = "\x41\x81\x42\xf0\x81\x81\x43";   
+        const char *badUTF8 = "\x41\x81\x42\xf0\x81\x81\x43";
         UChar32  c;
 
         ut = utext_openUTF8(NULL, badUTF8, -1, &status);
         TEST_SUCCESS(status);
         c = utext_char32At(ut, 1);
         TEST_ASSERT(c == 0xfffd);
         c = utext_char32At(ut, 3);
         TEST_ASSERT(c == 0xfffd);
         c = utext_char32At(ut, 5);
         TEST_ASSERT(c == 0xfffd);
@@ skipping 42 matching lines @@
     }
 
     //
     // Index to positions not on code point boundaries.
     //
     {
         const char *u8str =         "\xc8\x81\xe1\x82\x83\xf1\x84\x85\x86";
         int32_t startMap[] =        {   0,  0,  2,  2,  2,  5,  5,  5,  5,  9,  9};
         int32_t nextMap[]  =        {   2,  2,  5,  5,  5,  9,  9,  9,  9,  9,  9};
         int32_t prevMap[]  =        {   0,  0,  0,  0,  0,  2,  2,  2,  2,  5,  5};
-        UChar32  c32Map[] =    {0x201, 0x201, 0x1083, 0x1083, 0x1083, 0x044146, 0x044146, 0x044146, 0x044146, -1, -1}; 
-        UChar32  pr32Map[] =   {    -1,   -1,  0x201,  0x201,  0x201,   0x1083,   0x1083,   0x1083,   0x1083, 0x044146, 0x044146}; 
+        UChar32  c32Map[] =    {0x201, 0x201, 0x1083, 0x1083, 0x1083, 0x044146, 0x044146, 0x044146, 0x044146, -1, -1};
+        UChar32  pr32Map[] =   {    -1,   -1,  0x201,  0x201,  0x201,   0x1083,   0x1083,   0x1083,   0x1083, 0x044146, 0x044146};
 
         // extractLen is the size, in UChars, of what will be extracted between index and index+1.
         //  is zero when both index positions lie within the same code point.
         int32_t  exLen[] =          {   0,  1,   0,  0,  1,  0,  0,  0,  2,  0,  0};
 
 
         UErrorCode status = U_ZERO_ERROR;
         UText *ut = utext_openUTF8(NULL, u8str, -1, &status);
         TEST_SUCCESS(status);
 
@@ skipping 16 matching lines @@
             TEST_ASSERT(cpIndex == startMap[i]);
         }
 
         // Check utext_next32From
         for (i=0; i<startMapLimit; i++) {
             UChar32 c32 = utext_next32From(ut, i);
             TEST_ASSERT(c32 == c32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == nextMap[i]);
         }
-        
+
         // check utext_previous32From
         for (i=0; i<startMapLimit; i++) {
             gTestNum++;
             UChar32 c32 = utext_previous32From(ut, i);
             TEST_ASSERT(c32 == pr32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == prevMap[i]);
         }
 
         // check Extract
@@ skipping 12 matching lines @@
                 TEST_ASSERT(c32 == c32Map[i]);
             }
         }
 
         utext_close(ut);
     }
 
 
     {    //  Similar test, with utf16 instead of utf8
          //  TODO:  merge the common parts of these tests.
-        
+
         UnicodeString u16str("\\u1000\\U00011000\\u2000\\U00022000", -1, US_INV);
         int32_t startMap[]  ={ 0,     1,   1,    3,     4,  4,     6,  6};
         int32_t nextMap[]  = { 1,     3,   3,    4,     6,  6,     6,  6};
         int32_t prevMap[]  = { 0,     0,   0,    1,     3,  3,     4,  4};
-        UChar32  c32Map[] =  {0x1000, 0x11000, 0x11000, 0x2000,  0x22000, 0x22000, -1, -1}; 
-        UChar32  pr32Map[] = {    -1, 0x1000,  0x1000,  0x11000, 0x2000,  0x2000,   0x22000,   0x22000}; 
+        UChar32  c32Map[] =  {0x1000, 0x11000, 0x11000, 0x2000,  0x22000, 0x22000, -1, -1};
+        UChar32  pr32Map[] = {    -1, 0x1000,  0x1000,  0x11000, 0x2000,  0x2000,   0x22000,   0x22000};
         int32_t  exLen[] =   {   1,  0,   2,  1,  0,  2,  0,  0,};
 
         u16str = u16str.unescape();
         UErrorCode status = U_ZERO_ERROR;
         UText *ut = utext_openUnicodeString(NULL, &u16str, &status);
         TEST_SUCCESS(status);
 
         int32_t startMapLimit = sizeof(startMap) / sizeof(int32_t);
         int i;
         for (i=0; i<startMapLimit; i++) {
@@ skipping 10 matching lines @@
             TEST_ASSERT(cpIndex == startMap[i]);
         }
 
         // Check utext_next32From
         for (i=0; i<startMapLimit; i++) {
             UChar32 c32 = utext_next32From(ut, i);
             TEST_ASSERT(c32 == c32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == nextMap[i]);
         }
-        
+
         // check utext_previous32From
         for (i=0; i<startMapLimit; i++) {
             UChar32 c32 = utext_previous32From(ut, i);
             TEST_ASSERT(c32 == pr32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == prevMap[i]);
         }
 
         // check Extract
         //   Extract from i to i+1, which may be zero or one code points,
@@ skipping 10 matching lines @@
                 U16_GET(buf, 0, extractedLen-extractedLen, extractedLen, c32);
                 TEST_ASSERT(c32 == c32Map[i]);
             }
         }
 
         utext_close(ut);
     }
 
     {    //  Similar test, with UText over Replaceable
          //  TODO:  merge the common parts of these tests.
-        
+
         UnicodeString u16str("\\u1000\\U00011000\\u2000\\U00022000", -1, US_INV);
         int32_t startMap[]  ={ 0,     1,   1,    3,     4,  4,     6,  6};
         int32_t nextMap[]  = { 1,     3,   3,    4,     6,  6,     6,  6};
         int32_t prevMap[]  = { 0,     0,   0,    1,     3,  3,     4,  4};
-        UChar32  c32Map[] =  {0x1000, 0x11000, 0x11000, 0x2000,  0x22000, 0x22000, -1, -1}; 
-        UChar32  pr32Map[] = {    -1, 0x1000,  0x1000,  0x11000, 0x2000,  0x2000,   0x22000,   0x22000}; 
+        UChar32  c32Map[] =  {0x1000, 0x11000, 0x11000, 0x2000,  0x22000, 0x22000, -1, -1};
+        UChar32  pr32Map[] = {    -1, 0x1000,  0x1000,  0x11000, 0x2000,  0x2000,   0x22000,   0x22000};
         int32_t  exLen[] =   {   1,  0,   2,  1,  0,  2,  0,  0,};
 
         u16str = u16str.unescape();
         UErrorCode status = U_ZERO_ERROR;
         UText *ut = utext_openReplaceable(NULL, &u16str, &status);
         TEST_SUCCESS(status);
 
         int32_t startMapLimit = sizeof(startMap) / sizeof(int32_t);
         int i;
         for (i=0; i<startMapLimit; i++) {
@@ skipping 10 matching lines @@
             TEST_ASSERT(cpIndex == startMap[i]);
         }
 
         // Check utext_next32From
         for (i=0; i<startMapLimit; i++) {
             UChar32 c32 = utext_next32From(ut, i);
             TEST_ASSERT(c32 == c32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == nextMap[i]);
         }
-        
+
         // check utext_previous32From
         for (i=0; i<startMapLimit; i++) {
             UChar32 c32 = utext_previous32From(ut, i);
             TEST_ASSERT(c32 == pr32Map[i]);
             int64_t cpIndex = utext_getNativeIndex(ut);
             TEST_ASSERT(cpIndex == prevMap[i]);
         }
 
         // check Extract
         //   Extract from i to i+1, which may be zero or one code points,
@@ skipping 15 matching lines @@
         utext_close(ut);
     }
 }
 
 
 void UTextTest::FreezeTest() {
     // Check isWritable() and freeze() behavior.
     //
 
     UnicodeString  ustr("Hello, World.");
-    const char u8str[] = {char(0x31), (char)0x32, (char)0x33, 0};  
+    const char u8str[] = {char(0x31), (char)0x32, (char)0x33, 0};
     const UChar u16str[] = {(UChar)0x31, (UChar)0x32, (UChar)0x44, 0};
 
     UErrorCode status = U_ZERO_ERROR;
     UText  *ut        = NULL;
     UText  *ut2       = NULL;
 
     ut = utext_openUTF8(ut, u8str, -1, &status);
     TEST_SUCCESS(status);
     UBool writable = utext_isWritable(ut);
     TEST_ASSERT(writable == FALSE);
@@ skipping 11 matching lines @@
     status = U_ZERO_ERROR;
     ut = utext_openUnicodeString(ut, &ustr, &status);
     TEST_SUCCESS(status);
     writable = utext_isWritable(ut);
     TEST_ASSERT(writable == TRUE);
     utext_freeze(ut);
     writable = utext_isWritable(ut);
     TEST_ASSERT(writable == FALSE);
     utext_copy(ut, 1, 2, 0, TRUE, &status);
     TEST_ASSERT(status == U_NO_WRITE_PERMISSION);
-    
+
     status = U_ZERO_ERROR;
     ut = utext_openUnicodeString(ut, &ustr, &status);
     TEST_SUCCESS(status);
     ut2 = utext_clone(ut2, ut, FALSE, FALSE, &status);  // clone with readonly = false
     TEST_SUCCESS(status);
     writable = utext_isWritable(ut2);
     TEST_ASSERT(writable == TRUE);
     ut2 = utext_clone(ut2, ut, FALSE, TRUE, &status);  // clone with readonly = true
     TEST_SUCCESS(status);
     writable = utext_isWritable(ut2);
@@ skipping 62 matching lines @@
         return true;
     }
     if (!forward && index>0 && index <=length) {
         c = us->charAt((int32_t)index-1);
         ut->b = c | c<<16;
         ut->chunkOffset = 1;
         ut->chunkLength = 1;
         ut->chunkNativeStart = index-1;
         ut->chunkNativeLimit = index;
         return true;
-    } 
+    }
     ut->b = 0;
     ut->chunkOffset = 0;
     ut->chunkLength = 0;
     if (index <= 0) {
         ut->chunkNativeStart = 0;
         ut->chunkNativeLimit = 0;
     } else {
         ut->chunkNativeStart = length;
         ut->chunkNativeLimit = length;
     }
@@ skipping 46 matching lines @@
 
 // Regression test for Ticket 5560
 //   Clone fails to update chunkContentPointer in the cloned copy.
 //   This is only an issue for UText types that work in a local buffer,
 //      (UTF-8 wrapper, for example)
 //
 //   The test:
 //     1.  Create an inital UText
 //     2.  Deep clone it.  Contents should match original.
 //     3.  Reset original to something different.
-//     4.  Check that clone contents did not change.  
+//     4.  Check that clone contents did not change.
 //
 void UTextTest::Ticket5560() {
     /* The following two strings are in UTF-8 even on EBCDIC platforms. */
     static const char s1[] = {0x41,0x42,0x43,0x44,0x45,0x46,0}; /* "ABCDEF" */
     static const char s2[] = {0x31,0x32,0x33,0x34,0x35,0x36,0}; /* "123456" */
         UErrorCode status = U_ZERO_ERROR;
 
         UText ut1 = UTEXT_INITIALIZER;
         UText ut2 = UTEXT_INITIALIZER;
 
@@ skipping 44 matching lines @@
         count++;
         nativeIndex = UTEXT_GETNATIVEINDEX(ut);
         TEST_ASSERT(nativeIndex == count);
     }
     TEST_ASSERT(count == STRLEN);
     nativeIndex = UTEXT_GETNATIVEINDEX(ut);
     TEST_ASSERT(nativeIndex == STRLEN);
     utext_close(ut);
 }
 
+
+void UTextTest::Ticket10562() {
+    // Note: failures show as a heap error when the test is run under valgrind.
+    UErrorCode status = U_ZERO_ERROR;
+
+    const char *utf8_string = "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41";
+    UText *utf8Text = utext_openUTF8(NULL, utf8_string, -1, &status);
+    TEST_SUCCESS(status);
+    UText *deepClone = utext_clone(NULL, utf8Text, TRUE, FALSE, &status);
+    TEST_SUCCESS(status);
+    UText *shallowClone = utext_clone(NULL, deepClone, FALSE, FALSE, &status);
+    TEST_SUCCESS(status);
+    utext_close(shallowClone);
+    utext_close(deepClone);
+    utext_close(utf8Text);
+
+    status = U_ZERO_ERROR;
+    UnicodeString usString("Hello, World.");
+    UText *usText = utext_openUnicodeString(NULL, &usString, &status);
+    TEST_SUCCESS(status);
+    UText *usDeepClone = utext_clone(NULL, usText, TRUE, FALSE, &status);
+    TEST_SUCCESS(status);
+    UText *usShallowClone = utext_clone(NULL, usDeepClone, FALSE, FALSE, &status);
+    TEST_SUCCESS(status);
+    utext_close(usShallowClone);
+    utext_close(usDeepClone);
+    utext_close(usText);
+}
+
+
+void UTextTest::Ticket10983() {
+    // Note: failure shows as a seg fault when the defect is present.
+
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString s("Hello, World");
+    UText *ut = utext_openConstUnicodeString(NULL, &s, &status);
+    TEST_SUCCESS(status);
+
+    status = U_INVALID_STATE_ERROR;
+    UText *cloned = utext_clone(NULL, ut, TRUE, TRUE, &status);
+    TEST_ASSERT(cloned == NULL);
+    TEST_ASSERT(status == U_INVALID_STATE_ERROR);
+
+    utext_close(ut);
+}