Home | History | Annotate | Download | only in cintltst
      1 /********************************************************************
      2  * COPYRIGHT:
      3  * Copyright (c) 2001-2014, International Business Machines Corporation and
      4  * others. All Rights Reserved.
      5  ********************************************************************/
      6 /********************************************************************************
      7 *
      8 * File custrtrn.C
      9 *
     10 * Modification History:
     11 *        Name                     Description
     12 *        Ram                      String transformations test
     13 *********************************************************************************
     14 */
     15 /****************************************************************************/
     16 
     17 
     18 #include <stdlib.h>
     19 #include <stdio.h>
     20 #include <string.h>
     21 #include "unicode/utypes.h"
     22 #include "unicode/ustring.h"
     23 #include "unicode/ures.h"
     24 #include "ustr_imp.h"
     25 #include "cintltst.h"
     26 #include "cmemory.h"
     27 #include "cstring.h"
     28 #include "cwchar.h"
     29 
     30 void addUCharTransformTest(TestNode** root);
     31 
     32 static void Test_strToUTF32(void);
     33 static void Test_strToUTF32_surrogates(void);
     34 static void Test_strFromUTF32(void);
     35 static void Test_strFromUTF32_surrogates(void);
     36 static void Test_UChar_UTF8_API(void);
     37 static void Test_FromUTF8(void);
     38 static void Test_FromUTF8Lenient(void);
     39 static void Test_UChar_WCHART_API(void);
     40 static void Test_widestrs(void);
     41 static void Test_WCHART_LongString(void);
     42 static void Test_strToJavaModifiedUTF8(void);
     43 static void Test_strFromJavaModifiedUTF8(void);
     44 static void TestNullEmptySource(void);
     45 
     46 void
     47 addUCharTransformTest(TestNode** root)
     48 {
     49    addTest(root, &Test_strToUTF32, "custrtrn/Test_strToUTF32");
     50    addTest(root, &Test_strToUTF32_surrogates, "custrtrn/Test_strToUTF32_surrogates");
     51    addTest(root, &Test_strFromUTF32, "custrtrn/Test_strFromUTF32");
     52    addTest(root, &Test_strFromUTF32_surrogates, "custrtrn/Test_strFromUTF32_surrogates");
     53    addTest(root, &Test_UChar_UTF8_API, "custrtrn/Test_UChar_UTF8_API");
     54    addTest(root, &Test_FromUTF8, "custrtrn/Test_FromUTF8");
     55    addTest(root, &Test_FromUTF8Lenient, "custrtrn/Test_FromUTF8Lenient");
     56    addTest(root, &Test_UChar_WCHART_API,  "custrtrn/Test_UChar_WCHART_API");
     57    addTest(root, &Test_widestrs,  "custrtrn/Test_widestrs");
     58 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
     59    addTest(root, &Test_WCHART_LongString, "custrtrn/Test_WCHART_LongString");
     60 #endif
     61    addTest(root, &Test_strToJavaModifiedUTF8,  "custrtrn/Test_strToJavaModifiedUTF8");
     62    addTest(root, &Test_strFromJavaModifiedUTF8,  "custrtrn/Test_strFromJavaModifiedUTF8");
     63    addTest(root, &TestNullEmptySource,  "custrtrn/TestNullEmptySource");
     64 }
     65 
     66 static const UChar32 src32[]={
     67     0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
     68     0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
     69     0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
     70     0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
     71     0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
     72     0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
     73     0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
     74     0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
     75     0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
     76     0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
     77     0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
     78     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
     79     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
     80     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
     81     0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
     82     0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
     83     0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
     84     0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
     85     0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A,
     86     /* test non-BMP code points */
     87     0x0002A699,
     88     0x0002A69C, 0x0002A69D, 0x0002A69E, 0x0002A69F, 0x0002A6A0, 0x0002A6A5, 0x0002A6A6, 0x0002A6A7, 0x0002A6A8, 0x0002A6AB,
     89     0x0002A6AC, 0x0002A6AD, 0x0002A6AE, 0x0002A6AF, 0x0002A6B0, 0x0002A6B1, 0x0002A6B3, 0x0002A6B5, 0x0002A6B6, 0x0002A6B7,
     90     0x0002A6B8, 0x0002A6B9, 0x0002A6BA, 0x0002A6BB, 0x0002A6BC, 0x0002A6BD, 0x0002A6BE, 0x0002A6BF, 0x0002A6C0, 0x0002A6C1,
     91     0x0002A6C2, 0x0002A6C3, 0x0002A6C4, 0x0002A6C8, 0x0002A6CA, 0x0002A6CB, 0x0002A6CD, 0x0002A6CE, 0x0002A6CF, 0x0002A6D0,
     92     0x0002A6D1, 0x0002A6D2, 0x0002A6D3, 0x0002A6D4, 0x0002A6D5,
     93 
     94     0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
     95     0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
     96     0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
     97     0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
     98     0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,0x0000
     99 };
    100 
    101 static const UChar src16[] = {
    102     0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
    103     0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
    104     0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
    105     0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
    106     0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
    107     0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
    108     0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
    109     0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
    110     0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
    111     0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
    112     0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
    113     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
    114     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
    115     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
    116     0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
    117     0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
    118     0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
    119     0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
    120     0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A,
    121 
    122     /* test non-BMP code points */
    123     0xD869, 0xDE99, 0xD869, 0xDE9C, 0xD869, 0xDE9D, 0xD869, 0xDE9E, 0xD869, 0xDE9F,
    124     0xD869, 0xDEA0, 0xD869, 0xDEA5, 0xD869, 0xDEA6, 0xD869, 0xDEA7, 0xD869, 0xDEA8,
    125     0xD869, 0xDEAB, 0xD869, 0xDEAC, 0xD869, 0xDEAD, 0xD869, 0xDEAE, 0xD869, 0xDEAF,
    126     0xD869, 0xDEB0, 0xD869, 0xDEB1, 0xD869, 0xDEB3, 0xD869, 0xDEB5, 0xD869, 0xDEB6,
    127     0xD869, 0xDEB7, 0xD869, 0xDEB8, 0xD869, 0xDEB9, 0xD869, 0xDEBA, 0xD869, 0xDEBB,
    128     0xD869, 0xDEBC, 0xD869, 0xDEBD, 0xD869, 0xDEBE, 0xD869, 0xDEBF, 0xD869, 0xDEC0,
    129     0xD869, 0xDEC1, 0xD869, 0xDEC2, 0xD869, 0xDEC3, 0xD869, 0xDEC4, 0xD869, 0xDEC8,
    130     0xD869, 0xDECA, 0xD869, 0xDECB, 0xD869, 0xDECD, 0xD869, 0xDECE, 0xD869, 0xDECF,
    131     0xD869, 0xDED0, 0xD869, 0xDED1, 0xD869, 0xDED2, 0xD869, 0xDED3, 0xD869, 0xDED4,
    132     0xD869, 0xDED5,
    133 
    134     0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
    135     0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
    136     0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
    137     0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
    138     0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,0x0000
    139 };
    140 
    141 
    142 static void Test_strToUTF32(void){
    143     UErrorCode err = U_ZERO_ERROR;
    144     UChar32 u32Target[400];
    145     int32_t u32DestLen;
    146     int i= 0;
    147 
    148     /* first with length */
    149     u32DestLen = -2;
    150     u_strToUTF32(u32Target, 0, &u32DestLen, src16, UPRV_LENGTHOF(src16),&err);
    151     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != UPRV_LENGTHOF(src32)) {
    152         log_err("u_strToUTF32(preflight with length): "
    153                 "length %ld != %ld and %s != U_BUFFER_OVERFLOW_ERROR\n",
    154                 (long)u32DestLen, (long)UPRV_LENGTHOF(src32), u_errorName(err));
    155         return;
    156     }
    157     err = U_ZERO_ERROR;
    158     u32DestLen = -2;
    159     u_strToUTF32(u32Target, UPRV_LENGTHOF(src32)+1, &u32DestLen, src16, UPRV_LENGTHOF(src16),&err);
    160     if(err != U_ZERO_ERROR || u32DestLen != UPRV_LENGTHOF(src32)) {
    161         log_err("u_strToUTF32(with length): "
    162                 "length %ld != %ld and %s != U_ZERO_ERROR\n",
    163                 (long)u32DestLen, (long)UPRV_LENGTHOF(src32), u_errorName(err));
    164         return;
    165     }
    166     /*for(i=0; i< u32DestLen; i++){
    167         printf("0x%08X, ",uTarget[i]);
    168         if(i%10==0){
    169             printf("\n");
    170         }
    171     }*/
    172     for(i=0; i< UPRV_LENGTHOF(src32); i++){
    173         if(u32Target[i] != src32[i]){
    174             log_verbose("u_strToUTF32(with length) failed expected: %04X got: %04X at index: %i \n", src32[i], u32Target[i],i);
    175         }
    176     }
    177     if(u32Target[i] != 0){
    178         log_verbose("u_strToUTF32(with length) failed expected: %04X got: %04X at index: %i \n", 0, u32Target[i],i);
    179     }
    180 
    181     /* now NUL-terminated */
    182     u32DestLen = -2;
    183     u_strToUTF32(NULL,0, &u32DestLen, src16, -1,&err);
    184     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != UPRV_LENGTHOF(src32)-1) {
    185         log_err("u_strToUTF32(preflight with NUL-termination): "
    186                 "length %ld != %ld and %s != U_BUFFER_OVERFLOW_ERROR\n",
    187                 (long)u32DestLen, (long)UPRV_LENGTHOF(src32)-1, u_errorName(err));
    188         return;
    189     }
    190     err = U_ZERO_ERROR;
    191     u32DestLen = -2;
    192     u_strToUTF32(u32Target, UPRV_LENGTHOF(src32), &u32DestLen, src16, -1,&err);
    193     if(err != U_ZERO_ERROR || u32DestLen != UPRV_LENGTHOF(src32)-1) {
    194         log_err("u_strToUTF32(with NUL-termination): "
    195                 "length %ld != %ld and %s != U_ZERO_ERROR\n",
    196                 (long)u32DestLen, (long)UPRV_LENGTHOF(src32)-1, u_errorName(err));
    197         return;
    198     }
    199 
    200     for(i=0; i< UPRV_LENGTHOF(src32); i++){
    201         if(u32Target[i] != src32[i]){
    202             log_verbose("u_strToUTF32(NUL-termination) failed expected: %04X got: %04X \n", src32[i], u32Target[i]);
    203         }
    204     }
    205 }
    206 
    207 /* test unpaired surrogates */
    208 static void Test_strToUTF32_surrogates() {
    209     UErrorCode err = U_ZERO_ERROR;
    210     UChar32 u32Target[400];
    211     int32_t len16, u32DestLen;
    212     int32_t numSubstitutions;
    213     int i;
    214 
    215     static const UChar surr16[] = { 0x41, 0xd900, 0x61, 0xdc00, 0x5a, 0xd900, 0xdc00, 0x7a, 0 };
    216     static const UChar32 expected[] = { 0x5a, 0x50000, 0x7a, 0 };
    217     static const UChar32 expected_FFFD[] = { 0x41, 0xfffd, 0x61, 0xfffd, 0x5a, 0x50000, 0x7a, 0 };
    218     static const UChar32 expected_12345[] = { 0x41, 0x12345, 0x61, 0x12345, 0x5a, 0x50000, 0x7a, 0 };
    219     len16 = UPRV_LENGTHOF(surr16);
    220     for(i = 0; i < 4; ++i) {
    221         err = U_ZERO_ERROR;
    222         u_strToUTF32(u32Target, 0, &u32DestLen, surr16+i, len16-i, &err);
    223         if(err != U_INVALID_CHAR_FOUND) {
    224             log_err("u_strToUTF32(preflight surr16+%ld) sets %s != U_INVALID_CHAR_FOUND\n",
    225                     (long)i, u_errorName(err));
    226             return;
    227         }
    228 
    229         err = U_ZERO_ERROR;
    230         u_strToUTF32(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16+i, len16-i, &err);
    231         if(err != U_INVALID_CHAR_FOUND) {
    232             log_err("u_strToUTF32(surr16+%ld) sets %s != U_INVALID_CHAR_FOUND\n",
    233                     (long)i, u_errorName(err));
    234             return;
    235         }
    236 
    237         err = U_ZERO_ERROR;
    238         u_strToUTF32(NULL, 0, &u32DestLen, surr16+i, -1, &err);
    239         if(err != U_INVALID_CHAR_FOUND) {
    240             log_err("u_strToUTF32(preflight surr16+%ld/NUL) sets %s != U_INVALID_CHAR_FOUND\n",
    241                     (long)i, u_errorName(err));
    242             return;
    243         }
    244 
    245         err = U_ZERO_ERROR;
    246         u_strToUTF32(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16+i, -1, &err);
    247         if(err != U_INVALID_CHAR_FOUND) {
    248             log_err("u_strToUTF32(surr16+%ld/NUL) sets %s != U_INVALID_CHAR_FOUND\n",
    249                     (long)i, u_errorName(err));
    250             return;
    251         }
    252     }
    253 
    254     err = U_ZERO_ERROR;
    255     u_strToUTF32(u32Target, 0, &u32DestLen, surr16+4, len16-4-1, &err);
    256     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != 3) {
    257         log_err("u_strToUTF32(preflight surr16+4) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    258                 u_errorName(err));
    259         return;
    260     }
    261 
    262     err = U_ZERO_ERROR;
    263     u_strToUTF32(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16+4, len16-4-1, &err);
    264     if(err != U_ZERO_ERROR || u32DestLen != 3 || uprv_memcmp(u32Target, expected, 4*4)) {
    265         log_err("u_strToUTF32(surr16+4) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    266                 u_errorName(err));
    267         return;
    268     }
    269 
    270     err = U_ZERO_ERROR;
    271     u_strToUTF32(NULL, 0, &u32DestLen, surr16+4, -1, &err);
    272     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != 3) {
    273         log_err("u_strToUTF32(preflight surr16+4/NUL) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    274                 u_errorName(err));
    275         return;
    276     }
    277 
    278     err = U_ZERO_ERROR;
    279     u_strToUTF32(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16+4, -1, &err);
    280     if(err != U_ZERO_ERROR || u32DestLen != 3 || uprv_memcmp(u32Target, expected, 4*4)) {
    281         log_err("u_strToUTF32(surr16+4/NUL) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    282                 u_errorName(err));
    283         return;
    284     }
    285 
    286     /* with substitution character */
    287     numSubstitutions = -1;
    288     err = U_ZERO_ERROR;
    289     u_strToUTF32WithSub(u32Target, 0, &u32DestLen, surr16, len16-1, 0xfffd, &numSubstitutions, &err);
    290     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != 7 || numSubstitutions != 2) {
    291         log_err("u_strToUTF32WithSub(preflight surr16) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    292                 u_errorName(err));
    293         return;
    294     }
    295 
    296     err = U_ZERO_ERROR;
    297     u_strToUTF32WithSub(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16, len16-1, 0xfffd, &numSubstitutions, &err);
    298     if(err != U_ZERO_ERROR || u32DestLen != 7 || numSubstitutions != 2 || uprv_memcmp(u32Target, expected_FFFD, 8*4)) {
    299         log_err("u_strToUTF32WithSub(surr16) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    300                 u_errorName(err));
    301         return;
    302     }
    303 
    304     err = U_ZERO_ERROR;
    305     u_strToUTF32WithSub(NULL, 0, &u32DestLen, surr16, -1, 0x12345, &numSubstitutions, &err);
    306     if(err != U_BUFFER_OVERFLOW_ERROR || u32DestLen != 7 || numSubstitutions != 2) {
    307         log_err("u_strToUTF32WithSub(preflight surr16/NUL) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    308                 u_errorName(err));
    309         return;
    310     }
    311 
    312     err = U_ZERO_ERROR;
    313     u_strToUTF32WithSub(u32Target, UPRV_LENGTHOF(u32Target), &u32DestLen, surr16, -1, 0x12345, &numSubstitutions, &err);
    314     if(err != U_ZERO_ERROR || u32DestLen != 7 || numSubstitutions != 2 || uprv_memcmp(u32Target, expected_12345, 8*4)) {
    315         log_err("u_strToUTF32WithSub(surr16/NUL) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    316                 u_errorName(err));
    317         return;
    318     }
    319 }
    320 
    321 static void Test_strFromUTF32(void){
    322     UErrorCode err = U_ZERO_ERROR;
    323     UChar uTarget[400];
    324     int32_t uDestLen;
    325     int i= 0;
    326 
    327     /* first with length */
    328     uDestLen = -2;
    329     u_strFromUTF32(uTarget,0,&uDestLen,src32,UPRV_LENGTHOF(src32),&err);
    330     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != UPRV_LENGTHOF(src16)) {
    331         log_err("u_strFromUTF32(preflight with length): "
    332                 "length %ld != %ld and %s != U_BUFFER_OVERFLOW_ERROR\n",
    333                 (long)uDestLen, (long)UPRV_LENGTHOF(src16), u_errorName(err));
    334         return;
    335     }
    336     err = U_ZERO_ERROR;
    337     uDestLen = -2;
    338     u_strFromUTF32(uTarget, UPRV_LENGTHOF(src16)+1,&uDestLen,src32,UPRV_LENGTHOF(src32),&err);
    339     if(err != U_ZERO_ERROR || uDestLen != UPRV_LENGTHOF(src16)) {
    340         log_err("u_strFromUTF32(with length): "
    341                 "length %ld != %ld and %s != U_ZERO_ERROR\n",
    342                 (long)uDestLen, (long)UPRV_LENGTHOF(src16), u_errorName(err));
    343         return;
    344     }
    345     /*for(i=0; i< uDestLen; i++){
    346         printf("0x%04X, ",uTarget[i]);
    347         if(i%10==0){
    348             printf("\n");
    349         }
    350     }*/
    351 
    352     for(i=0; i< uDestLen; i++){
    353         if(uTarget[i] != src16[i]){
    354             log_verbose("u_strFromUTF32(with length) failed expected: %04X got: %04X at index: %i \n", src16[i] ,uTarget[i],i);
    355         }
    356     }
    357     if(uTarget[i] != 0){
    358         log_verbose("u_strFromUTF32(with length) failed expected: %04X got: %04X at index: %i \n", 0,uTarget[i],i);
    359     }
    360 
    361     /* now NUL-terminated */
    362     uDestLen = -2;
    363     u_strFromUTF32(NULL,0,&uDestLen,src32,-1,&err);
    364     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != UPRV_LENGTHOF(src16)-1) {
    365         log_err("u_strFromUTF32(preflight with NUL-termination): "
    366                 "length %ld != %ld and %s != U_BUFFER_OVERFLOW_ERROR\n",
    367                 (long)uDestLen, (long)UPRV_LENGTHOF(src16)-1, u_errorName(err));
    368         return;
    369     }
    370     err = U_ZERO_ERROR;
    371     uDestLen = -2;
    372     u_strFromUTF32(uTarget, UPRV_LENGTHOF(src16),&uDestLen,src32,-1,&err);
    373     if(err != U_ZERO_ERROR || uDestLen != UPRV_LENGTHOF(src16)-1) {
    374         log_err("u_strFromUTF32(with NUL-termination): "
    375                 "length %ld != %ld and %s != U_ZERO_ERROR\n",
    376                 (long)uDestLen, (long)UPRV_LENGTHOF(src16)-1, u_errorName(err));
    377         return;
    378     }
    379 
    380     for(i=0; i< uDestLen; i++){
    381         if(uTarget[i] != src16[i]){
    382             log_verbose("u_strFromUTF32(with NUL-termination) failed expected: %04X got: %04X \n", src16[i] ,uTarget[i]);
    383         }
    384     }
    385 }
    386 
    387 /* test surrogate code points */
    388 static void Test_strFromUTF32_surrogates() {
    389     UErrorCode err = U_ZERO_ERROR;
    390     UChar uTarget[400];
    391     int32_t len32, uDestLen;
    392     int32_t numSubstitutions;
    393     int i;
    394 
    395     static const UChar32 surr32[] = { 0x41, 0xd900, 0x61, 0xdc00, -1, 0x110000, 0x5a, 0x50000, 0x7a, 0 };
    396     static const UChar expected[] = { 0x5a, 0xd900, 0xdc00, 0x7a, 0 };
    397     static const UChar expected_FFFD[] = { 0x41, 0xfffd, 0x61, 0xfffd, 0xfffd, 0xfffd, 0x5a, 0xd900, 0xdc00, 0x7a, 0 };
    398     static const UChar expected_12345[] = { 0x41, 0xd808, 0xdf45, 0x61, 0xd808, 0xdf45, 0xd808, 0xdf45, 0xd808, 0xdf45,
    399                                             0x5a, 0xd900, 0xdc00, 0x7a, 0 };
    400     len32 = UPRV_LENGTHOF(surr32);
    401     for(i = 0; i < 6; ++i) {
    402         err = U_ZERO_ERROR;
    403         u_strFromUTF32(uTarget, 0, &uDestLen, surr32+i, len32-i, &err);
    404         if(err != U_INVALID_CHAR_FOUND) {
    405             log_err("u_strFromUTF32(preflight surr32+%ld) sets %s != U_INVALID_CHAR_FOUND\n",
    406                     (long)i, u_errorName(err));
    407             return;
    408         }
    409 
    410         err = U_ZERO_ERROR;
    411         u_strFromUTF32(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32+i, len32-i, &err);
    412         if(err != U_INVALID_CHAR_FOUND) {
    413             log_err("u_strFromUTF32(surr32+%ld) sets %s != U_INVALID_CHAR_FOUND\n",
    414                     (long)i, u_errorName(err));
    415             return;
    416         }
    417 
    418         err = U_ZERO_ERROR;
    419         u_strFromUTF32(NULL, 0, &uDestLen, surr32+i, -1, &err);
    420         if(err != U_INVALID_CHAR_FOUND) {
    421             log_err("u_strFromUTF32(preflight surr32+%ld/NUL) sets %s != U_INVALID_CHAR_FOUND\n",
    422                     (long)i, u_errorName(err));
    423             return;
    424         }
    425 
    426         err = U_ZERO_ERROR;
    427         u_strFromUTF32(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32+i, -1, &err);
    428         if(err != U_INVALID_CHAR_FOUND) {
    429             log_err("u_strFromUTF32(surr32+%ld/NUL) sets %s != U_INVALID_CHAR_FOUND\n",
    430                     (long)i, u_errorName(err));
    431             return;
    432         }
    433     }
    434 
    435     err = U_ZERO_ERROR;
    436     u_strFromUTF32(uTarget, 0, &uDestLen, surr32+6, len32-6-1, &err);
    437     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != 4) {
    438         log_err("u_strFromUTF32(preflight surr32+6) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    439                 u_errorName(err));
    440         return;
    441     }
    442 
    443     err = U_ZERO_ERROR;
    444     u_strFromUTF32(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32+6, len32-6-1, &err);
    445     if(err != U_ZERO_ERROR || uDestLen != 4 || u_memcmp(uTarget, expected, 5)) {
    446         log_err("u_strFromUTF32(surr32+6) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    447                 u_errorName(err));
    448         return;
    449     }
    450 
    451     err = U_ZERO_ERROR;
    452     u_strFromUTF32(NULL, 0, &uDestLen, surr32+6, -1, &err);
    453     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != 4) {
    454         log_err("u_strFromUTF32(preflight surr32+6/NUL) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    455                 u_errorName(err));
    456         return;
    457     }
    458 
    459     err = U_ZERO_ERROR;
    460     u_strFromUTF32(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32+6, -1, &err);
    461     if(err != U_ZERO_ERROR || uDestLen != 4 || u_memcmp(uTarget, expected, 5)) {
    462         log_err("u_strFromUTF32(surr32+6/NUL) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    463                 u_errorName(err));
    464         return;
    465     }
    466 
    467     /* with substitution character */
    468     numSubstitutions = -1;
    469     err = U_ZERO_ERROR;
    470     u_strFromUTF32WithSub(uTarget, 0, &uDestLen, surr32, len32-1, 0xfffd, &numSubstitutions, &err);
    471     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != 10 || numSubstitutions != 4) {
    472         log_err("u_strFromUTF32WithSub(preflight surr32) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    473                 u_errorName(err));
    474         return;
    475     }
    476 
    477     err = U_ZERO_ERROR;
    478     u_strFromUTF32WithSub(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32, len32-1, 0xfffd, &numSubstitutions, &err);
    479     if(err != U_ZERO_ERROR || uDestLen != 10 || numSubstitutions != 4 || u_memcmp(uTarget, expected_FFFD, 11)) {
    480         log_err("u_strFromUTF32WithSub(surr32) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    481                 u_errorName(err));
    482         return;
    483     }
    484 
    485     err = U_ZERO_ERROR;
    486     u_strFromUTF32WithSub(NULL, 0, &uDestLen, surr32, -1, 0x12345, &numSubstitutions, &err);
    487     if(err != U_BUFFER_OVERFLOW_ERROR || uDestLen != 14 || numSubstitutions != 4) {
    488         log_err("u_strFromUTF32WithSub(preflight surr32/NUL) sets %s != U_BUFFER_OVERFLOW_ERROR or an unexpected length\n",
    489                 u_errorName(err));
    490         return;
    491     }
    492 
    493     err = U_ZERO_ERROR;
    494     u_strFromUTF32WithSub(uTarget, UPRV_LENGTHOF(uTarget), &uDestLen, surr32, -1, 0x12345, &numSubstitutions, &err);
    495     if(err != U_ZERO_ERROR || uDestLen != 14 || numSubstitutions != 4 || u_memcmp(uTarget, expected_12345, 15)) {
    496         log_err("u_strFromUTF32WithSub(surr32/NUL) sets %s != U_ZERO_ERROR or does not produce the expected string\n",
    497                 u_errorName(err));
    498         return;
    499     }
    500 }
    501 
    502 static void Test_UChar_UTF8_API(void){
    503 
    504     UErrorCode err = U_ZERO_ERROR;
    505     UChar uTemp[1];
    506     char u8Temp[1];
    507     UChar* uTarget=uTemp;
    508     const char* u8Src;
    509     int32_t u8SrcLen = 0;
    510     int32_t uTargetLength = 0;
    511     int32_t uDestLen=0;
    512     const UChar* uSrc = src16;
    513     int32_t uSrcLen   = sizeof(src16)/2;
    514     char* u8Target = u8Temp;
    515     int32_t u8TargetLength =0;
    516     int32_t u8DestLen =0;
    517     UBool failed = FALSE;
    518     int i= 0;
    519     int32_t numSubstitutions;
    520 
    521     {
    522         /* preflight */
    523         u8Temp[0] = 0x12;
    524         u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
    525         if(err == U_BUFFER_OVERFLOW_ERROR && u8Temp[0] == 0x12){
    526             err = U_ZERO_ERROR;
    527             u8Target = (char*) malloc (sizeof(uint8_t) * (u8DestLen+1));
    528             u8TargetLength = u8DestLen;
    529 
    530             u8Target[u8TargetLength] = (char)0xfe;
    531             u8DestLen = -1;
    532             u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
    533             if(U_FAILURE(err) || u8DestLen != u8TargetLength || u8Target[u8TargetLength] != (char)0xfe){
    534                 log_err("u_strToUTF8 failed after preflight. Error: %s\n", u_errorName(err));
    535                 return;
    536             }
    537 
    538         }
    539         else {
    540             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
    541         }
    542         failed = FALSE;
    543         /*for(i=0; i< u8DestLen; i++){
    544             printf("0x%04X, ",u8Target[i]);
    545             if(i%10==0){
    546                 printf("\n");
    547             }
    548         }*/
    549         /*for(i=0; i< u8DestLen; i++){
    550             if(u8Target[i] != src8[i]){
    551                 log_verbose("u_strToUTF8() failed expected: %04X got: %04X \n", src8[i], u8Target[i]);
    552                 failed =TRUE;
    553             }
    554         }
    555         if(failed){
    556             log_err("u_strToUTF8() failed \n");
    557         }*/
    558         u8Src = u8Target;
    559         u8SrcLen = u8DestLen;
    560 
    561         /* preflight */
    562         uTemp[0] = 0x1234;
    563         u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
    564         if(err == U_BUFFER_OVERFLOW_ERROR && uTemp[0] == 0x1234){
    565             err = U_ZERO_ERROR;
    566             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
    567             uTargetLength =  uDestLen;
    568 
    569             uTarget[uTargetLength] = 0xfff0;
    570             uDestLen = -1;
    571             u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
    572         }
    573         else {
    574             log_err("error: u_strFromUTF8(preflight) should have gotten U_BUFFER_OVERFLOW_ERROR\n");
    575         }
    576         /*for(i=0; i< uDestLen; i++){
    577             printf("0x%04X, ",uTarget[i]);
    578             if(i%10==0){
    579                 printf("\n");
    580             }
    581         }*/
    582 
    583         if(U_FAILURE(err) || uDestLen != uTargetLength || uTarget[uTargetLength] != 0xfff0) {
    584             failed = TRUE;
    585         }
    586         for(i=0; i< uSrcLen; i++){
    587             if(uTarget[i] != src16[i]){
    588                 log_verbose("u_strFromUTF8() failed expected: \\u%04X got: \\u%04X at index: %i \n", src16[i] ,uTarget[i],i);
    589                 failed =TRUE;
    590             }
    591         }
    592         if(failed){
    593             log_err("error: u_strFromUTF8(after preflighting) failed\n");
    594         }
    595 
    596         free(u8Target);
    597         free(uTarget);
    598     }
    599     {
    600         u8SrcLen = -1;
    601         uTargetLength = 0;
    602         uSrcLen =-1;
    603         u8TargetLength=0;
    604         failed = FALSE;
    605         /* preflight */
    606         u_strToUTF8(NULL,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
    607         if(err == U_BUFFER_OVERFLOW_ERROR){
    608             err = U_ZERO_ERROR;
    609             u8Target = (char*) malloc (sizeof(uint8_t) * (u8DestLen+1));
    610             u8TargetLength = u8DestLen;
    611 
    612             u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
    613 
    614         }
    615         else {
    616             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
    617         }
    618         failed = FALSE;
    619         /*for(i=0; i< u8DestLen; i++){
    620             printf("0x%04X, ",u8Target[i]);
    621             if(i%10==0){
    622                 printf("\n");
    623             }
    624         }*/
    625         /*for(i=0; i< u8DestLen; i++){
    626             if(u8Target[i] != src8[i]){
    627                 log_verbose("u_strToUTF8() failed expected: %04X got: %04X \n", src8[i], u8Target[i]);
    628                 failed =TRUE;
    629             }
    630         }
    631         if(failed){
    632             log_err("u_strToUTF8() failed \n");
    633         }*/
    634         u8Src = u8Target;
    635         u8SrcLen = u8DestLen;
    636 
    637         /* preflight */
    638         u_strFromUTF8(NULL,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
    639         if(err == U_BUFFER_OVERFLOW_ERROR){
    640             err = U_ZERO_ERROR;
    641             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
    642             uTargetLength =  uDestLen;
    643 
    644             u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
    645         }
    646         else {
    647             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
    648         }
    649         /*for(i=0; i< uDestLen; i++){
    650             printf("0x%04X, ",uTarget[i]);
    651             if(i%10==0){
    652                 printf("\n");
    653             }
    654         }*/
    655 
    656         for(i=0; i< uSrcLen; i++){
    657             if(uTarget[i] != src16[i]){
    658                 log_verbose("u_strFromUTF8() failed expected: \\u%04X got: \\u%04X at index: %i \n", src16[i] ,uTarget[i],i);
    659                 failed =TRUE;
    660             }
    661         }
    662         if(failed){
    663             log_err("u_strToUTF8() failed \n");
    664         }
    665 
    666         free(u8Target);
    667         free(uTarget);
    668     }
    669 
    670     /* test UTF-8 with single surrogates - illegal in Unicode 3.2 */
    671     {
    672         static const UChar
    673             withLead16[]={ 0x1800, 0xd89a, 0x0061 },
    674             withTrail16[]={ 0x1800, 0xdcba, 0x0061, 0 },
    675             withTrail16SubFFFD[]={ 0x1800, 0xfffd, 0x0061, 0 }, /* sub==U+FFFD */
    676             withTrail16Sub50005[]={ 0x1800, 0xd900, 0xdc05, 0x0061, 0 }; /* sub==U+50005 */
    677         static const uint8_t
    678             withLead8[]={ 0xe1, 0xa0, 0x80, 0xed, 0xa2, 0x9a, 0x61 },
    679             withTrail8[]={ 0xe1, 0xa0, 0x80, 0xed, 0xb2, 0xba, 0x61, 0 },
    680             withTrail8Sub1A[]={ 0xe1, 0xa0, 0x80, 0x1a, 0x61, 0 }, /* sub==U+001A */
    681             withTrail8SubFFFD[]={ 0xe1, 0xa0, 0x80, 0xef, 0xbf, 0xbd, 0x61, 0 }; /* sub==U+FFFD */
    682         UChar out16[10];
    683         char out8[10];
    684 
    685         if(
    686             (err=U_ZERO_ERROR, u_strToUTF8(out8, UPRV_LENGTHOF(out8), NULL, withLead16, UPRV_LENGTHOF(withLead16), &err), err!=U_INVALID_CHAR_FOUND) ||
    687             (err=U_ZERO_ERROR, u_strToUTF8(out8, UPRV_LENGTHOF(out8), NULL, withTrail16, -1, &err), err!=U_INVALID_CHAR_FOUND) ||
    688             (err=U_ZERO_ERROR, u_strFromUTF8(out16, UPRV_LENGTHOF(out16), NULL, (const char *)withLead8, UPRV_LENGTHOF(withLead8), &err), err!=U_INVALID_CHAR_FOUND) ||
    689             (err=U_ZERO_ERROR, u_strFromUTF8(out16, UPRV_LENGTHOF(out16), NULL, (const char *)withTrail8, -1, &err), err!=U_INVALID_CHAR_FOUND)
    690         ) {
    691             log_err("error: u_strTo/FromUTF8(string with single surrogate) fails to report error\n");
    692         }
    693 
    694         /* test error handling with substitution characters */
    695 
    696         /* from UTF-8 with length */
    697         err=U_ZERO_ERROR;
    698         numSubstitutions=-1;
    699         out16[0]=0x55aa;
    700         uDestLen=0;
    701         u_strFromUTF8WithSub(out16, UPRV_LENGTHOF(out16), &uDestLen,
    702                              (const char *)withTrail8, uprv_strlen((const char *)withTrail8),
    703                              0x50005, &numSubstitutions,
    704                              &err);
    705         if(U_FAILURE(err) || uDestLen!=u_strlen(withTrail16Sub50005) ||
    706                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen+1) ||
    707                              numSubstitutions!=1) {
    708             log_err("error: u_strFromUTF8WithSub(length) failed\n");
    709         }
    710 
    711         /* from UTF-8 with NUL termination */
    712         err=U_ZERO_ERROR;
    713         numSubstitutions=-1;
    714         out16[0]=0x55aa;
    715         uDestLen=0;
    716         u_strFromUTF8WithSub(out16, UPRV_LENGTHOF(out16), &uDestLen,
    717                              (const char *)withTrail8, -1,
    718                              0xfffd, &numSubstitutions,
    719                              &err);
    720         if(U_FAILURE(err) || uDestLen!=u_strlen(withTrail16SubFFFD) ||
    721                              0!=u_memcmp(withTrail16SubFFFD, out16, uDestLen+1) ||
    722                              numSubstitutions!=1) {
    723             log_err("error: u_strFromUTF8WithSub(NUL termination) failed\n");
    724         }
    725 
    726         /* preflight from UTF-8 with NUL termination */
    727         err=U_ZERO_ERROR;
    728         numSubstitutions=-1;
    729         out16[0]=0x55aa;
    730         uDestLen=0;
    731         u_strFromUTF8WithSub(out16, 1, &uDestLen,
    732                              (const char *)withTrail8, -1,
    733                              0x50005, &numSubstitutions,
    734                              &err);
    735         if(err!=U_BUFFER_OVERFLOW_ERROR || uDestLen!=u_strlen(withTrail16Sub50005) || numSubstitutions!=1) {
    736             log_err("error: u_strFromUTF8WithSub(preflight/NUL termination) failed\n");
    737         }
    738 
    739         /* to UTF-8 with length */
    740         err=U_ZERO_ERROR;
    741         numSubstitutions=-1;
    742         out8[0]=(char)0xf5;
    743         u8DestLen=0;
    744         u_strToUTF8WithSub(out8, UPRV_LENGTHOF(out8), &u8DestLen,
    745                            withTrail16, u_strlen(withTrail16),
    746                            0xfffd, &numSubstitutions,
    747                            &err);
    748         if(U_FAILURE(err) || u8DestLen!=uprv_strlen((const char *)withTrail8SubFFFD) ||
    749                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen+1) ||
    750                              numSubstitutions!=1) {
    751             log_err("error: u_strToUTF8WithSub(length) failed\n");
    752         }
    753 
    754         /* to UTF-8 with NUL termination */
    755         err=U_ZERO_ERROR;
    756         numSubstitutions=-1;
    757         out8[0]=(char)0xf5;
    758         u8DestLen=0;
    759         u_strToUTF8WithSub(out8, UPRV_LENGTHOF(out8), &u8DestLen,
    760                            withTrail16, -1,
    761                            0x1a, &numSubstitutions,
    762                            &err);
    763         if(U_FAILURE(err) || u8DestLen!=uprv_strlen((const char *)withTrail8Sub1A) ||
    764                              0!=uprv_memcmp((const char *)withTrail8Sub1A, out8, u8DestLen+1) ||
    765                              numSubstitutions!=1) {
    766             log_err("error: u_strToUTF8WithSub(NUL termination) failed\n");
    767         }
    768 
    769         /* preflight to UTF-8 with NUL termination */
    770         err=U_ZERO_ERROR;
    771         numSubstitutions=-1;
    772         out8[0]=(char)0xf5;
    773         u8DestLen=0;
    774         u_strToUTF8WithSub(out8, 1, &u8DestLen,
    775                            withTrail16, -1,
    776                            0xfffd, &numSubstitutions,
    777                            &err);
    778         if(err!=U_BUFFER_OVERFLOW_ERROR || u8DestLen!=uprv_strlen((const char *)withTrail8SubFFFD) ||
    779                                            numSubstitutions!=1) {
    780             log_err("error: u_strToUTF8WithSub(preflight/NUL termination) failed\n");
    781         }
    782 
    783         /* test that numSubstitutions==0 if there are no substitutions */
    784 
    785         /* from UTF-8 with length (just first 3 bytes which are valid) */
    786         err=U_ZERO_ERROR;
    787         numSubstitutions=-1;
    788         out16[0]=0x55aa;
    789         uDestLen=0;
    790         u_strFromUTF8WithSub(out16, UPRV_LENGTHOF(out16), &uDestLen,
    791                              (const char *)withTrail8, 3,
    792                              0x50005, &numSubstitutions,
    793                              &err);
    794         if(U_FAILURE(err) || uDestLen!=1 ||
    795                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen) ||
    796                              numSubstitutions!=0) {
    797             log_err("error: u_strFromUTF8WithSub(no subs) failed\n");
    798         }
    799 
    800         /* to UTF-8 with length (just first UChar which is valid) */
    801         err=U_ZERO_ERROR;
    802         numSubstitutions=-1;
    803         out8[0]=(char)0xf5;
    804         u8DestLen=0;
    805         u_strToUTF8WithSub(out8, UPRV_LENGTHOF(out8), &u8DestLen,
    806                            withTrail16, 1,
    807                            0xfffd, &numSubstitutions,
    808                            &err);
    809         if(U_FAILURE(err) || u8DestLen!=3 ||
    810                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen) ||
    811                              numSubstitutions!=0) {
    812             log_err("error: u_strToUTF8WithSub(no subs) failed\n");
    813         }
    814 
    815         /* test that numSubstitutions==0 if subchar==U_SENTINEL (no subchar) */
    816 
    817         /* from UTF-8 with length (just first 3 bytes which are valid) */
    818         err=U_ZERO_ERROR;
    819         numSubstitutions=-1;
    820         out16[0]=0x55aa;
    821         uDestLen=0;
    822         u_strFromUTF8WithSub(out16, UPRV_LENGTHOF(out16), &uDestLen,
    823                              (const char *)withTrail8, 3,
    824                              U_SENTINEL, &numSubstitutions,
    825                              &err);
    826         if(U_FAILURE(err) || uDestLen!=1 ||
    827                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen) ||
    828                              numSubstitutions!=0) {
    829             log_err("error: u_strFromUTF8WithSub(no subchar) failed\n");
    830         }
    831 
    832         /* to UTF-8 with length (just first UChar which is valid) */
    833         err=U_ZERO_ERROR;
    834         numSubstitutions=-1;
    835         out8[0]=(char)0xf5;
    836         u8DestLen=0;
    837         u_strToUTF8WithSub(out8, UPRV_LENGTHOF(out8), &u8DestLen,
    838                            withTrail16, 1,
    839                            U_SENTINEL, &numSubstitutions,
    840                            &err);
    841         if(U_FAILURE(err) || u8DestLen!=3 ||
    842                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen) ||
    843                              numSubstitutions!=0) {
    844             log_err("error: u_strToUTF8WithSub(no subchar) failed\n");
    845         }
    846     }
    847     {
    848         /*
    849          * Test with an illegal lead byte that would be followed by more than 3 trail bytes.
    850          * See ticket #10371.
    851          */
    852         static const char src[1]={ (char)0xf8 };
    853         UChar out16[10];
    854         err=U_ZERO_ERROR;
    855         u_strFromUTF8(out16, UPRV_LENGTHOF(out16), NULL, src, 1, &err);
    856         if(err!=U_INVALID_CHAR_FOUND) {
    857             log_err("error: u_strFromUTF8(5-byte lead byte) failed\n");
    858         }
    859     }
    860 }
    861 
    862 /* compare if two strings are equal, but match 0xfffd in the second string with anything in the first */
    863 static UBool
    864 equalAnyFFFD(const UChar *s, const UChar *t, int32_t length) {
    865     UChar c1, c2;
    866 
    867     while(length>0) {
    868         c1=*s++;
    869         c2=*t++;
    870         if(c1!=c2 && c2!=0xfffd) {
    871             return FALSE;
    872         }
    873         --length;
    874     }
    875     return TRUE;
    876 }
    877 
    878 /* test u_strFromUTF8Lenient() */
    879 static void
    880 Test_FromUTF8(void) {
    881     /*
    882      * Test case from icu-support list 20071130 "u_strFromUTF8() returns U_INVALID_CHAR_FOUND(10)"
    883      */
    884     static const uint8_t bytes[]={ 0xe0, 0xa5, 0x9c, 0 };
    885     UChar dest[64];
    886     UChar *destPointer;
    887     int32_t destLength;
    888     UErrorCode errorCode;
    889 
    890     /* 3 bytes input, one UChar output (U+095C) */
    891     errorCode=U_ZERO_ERROR;
    892     destLength=-99;
    893     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, 3, &errorCode);
    894     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=1) {
    895         log_err("error: u_strFromUTF8(preflight srcLength=3) fails: destLength=%ld - %s\n",
    896                 (long)destLength, u_errorName(errorCode));
    897     }
    898 
    899     /* 4 bytes input, two UChars output (U+095C U+0000) */
    900     errorCode=U_ZERO_ERROR;
    901     destLength=-99;
    902     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, 4, &errorCode);
    903     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=2) {
    904         log_err("error: u_strFromUTF8(preflight srcLength=4) fails: destLength=%ld - %s\n",
    905                 (long)destLength, u_errorName(errorCode));
    906     }
    907 
    908     /* NUL-terminated 3 bytes input, one UChar output (U+095C) */
    909     errorCode=U_ZERO_ERROR;
    910     destLength=-99;
    911     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, -1, &errorCode);
    912     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=1) {
    913         log_err("error: u_strFromUTF8(preflight srcLength=-1) fails: destLength=%ld - %s\n",
    914                 (long)destLength, u_errorName(errorCode));
    915     }
    916 
    917     /* 3 bytes input, one UChar output (U+095C), transform not just preflight */
    918     errorCode=U_ZERO_ERROR;
    919     dest[0]=dest[1]=99;
    920     destLength=-99;
    921     destPointer=u_strFromUTF8(dest, UPRV_LENGTHOF(dest), &destLength, (const char *)bytes, 3, &errorCode);
    922     if(U_FAILURE(errorCode) || destPointer!=dest || destLength!=1 || dest[0]!=0x95c || dest[1]!=0) {
    923         log_err("error: u_strFromUTF8(transform srcLength=3) fails: destLength=%ld - %s\n",
    924                 (long)destLength, u_errorName(errorCode));
    925     }
    926 }
    927 
    928 /* test u_strFromUTF8Lenient() */
    929 static void
    930 Test_FromUTF8Lenient(void) {
    931     /*
    932      * Multiple input strings, each NUL-terminated.
    933      * Terminate with a string starting with 0xff.
    934      */
    935     static const uint8_t bytes[]={
    936         /* well-formed UTF-8 */
    937         0x61,  0xc3, 0x9f,  0xe0, 0xa0, 0x80,  0xf0, 0xa0, 0x80, 0x80,
    938         0x62,  0xc3, 0xa0,  0xe0, 0xa0, 0x81,  0xf0, 0xa0, 0x80, 0x81, 0,
    939 
    940         /* various malformed sequences */
    941         0xc3, 0xc3, 0x9f,  0xc3, 0xa0,  0xe0, 0x80, 0x8a,  0xf0, 0x41, 0x42, 0x43, 0,
    942 
    943         /* truncated input */
    944         0xc3, 0,
    945         0xe0, 0,
    946         0xe0, 0xa0, 0,
    947         0xf0, 0,
    948         0xf0, 0x90, 0,
    949         0xf0, 0x90, 0x80, 0,
    950 
    951         /* non-ASCII characters in the last few bytes */
    952         0x61,  0xc3, 0x9f,  0xe0, 0xa0, 0x80, 0,
    953         0x61,  0xe0, 0xa0, 0x80,  0xc3, 0x9f, 0,
    954 
    955         /* empty string */
    956         0,
    957 
    958         /* finish */
    959         0xff, 0
    960     };
    961 
    962     /* Multiple output strings, each NUL-terminated. 0xfffd matches anything. */
    963     static const UChar uchars[]={
    964         0x61, 0xdf, 0x800,  0xd840, 0xdc00,
    965         0x62, 0xe0, 0x801,  0xd840, 0xdc01,  0,
    966 
    967         0xfffd, 0x9f, 0xe0, 0xa,  0xfffd, 0xfffd,  0,
    968 
    969         0xfffd, 0,
    970         0xfffd, 0,
    971         0xfffd, 0,
    972         0xfffd, 0,
    973         0xfffd, 0,
    974         0xfffd, 0,
    975 
    976         0x61, 0xdf, 0x800,  0,
    977         0x61, 0x800, 0xdf,  0,
    978 
    979         0,
    980 
    981         0
    982     };
    983 
    984     UChar dest[64];
    985     const char *pb;
    986     const UChar *pu, *pDest;
    987     int32_t srcLength, destLength0, destLength;
    988     int number;
    989     UErrorCode errorCode;
    990 
    991     /* verify checking for some illegal arguments */
    992     dest[0]=0x1234;
    993     destLength=-1;
    994     errorCode=U_ZERO_ERROR;
    995     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, NULL, -1, &errorCode);
    996     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0x1234) {
    997         log_err("u_strFromUTF8Lenient(src=NULL) failed\n");
    998     }
    999 
   1000     dest[0]=0x1234;
   1001     destLength=-1;
   1002     errorCode=U_ZERO_ERROR;
   1003     pDest=u_strFromUTF8Lenient(NULL, 1, &destLength, (const char *)bytes, -1, &errorCode);
   1004     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
   1005         log_err("u_strFromUTF8Lenient(dest=NULL[1]) failed\n");
   1006     }
   1007 
   1008     dest[0]=0x1234;
   1009     destLength=-1;
   1010     errorCode=U_MEMORY_ALLOCATION_ERROR;
   1011     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, (const char *)bytes, -1, &errorCode);
   1012     if(errorCode!=U_MEMORY_ALLOCATION_ERROR || dest[0]!=0x1234) {
   1013         log_err("u_strFromUTF8Lenient(U_MEMORY_ALLOCATION_ERROR) failed\n");
   1014     }
   1015 
   1016     dest[0]=0x1234;
   1017     destLength=-1;
   1018     errorCode=U_MEMORY_ALLOCATION_ERROR;
   1019     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, (const char *)bytes, -1, NULL);
   1020     if(dest[0]!=0x1234) {
   1021         log_err("u_strFromUTF8Lenient(pErrorCode=NULL) failed\n");
   1022     }
   1023 
   1024     /* test normal behavior */
   1025     number=0; /* string number for log_err() */
   1026 
   1027     for(pb=(const char *)bytes, pu=uchars;
   1028         *pb!=(char)0xff;
   1029         pb+=srcLength+1, pu+=destLength0+1, ++number
   1030     ) {
   1031         srcLength=uprv_strlen(pb);
   1032         destLength0=u_strlen(pu);
   1033 
   1034         /* preflighting with NUL-termination */
   1035         dest[0]=0x1234;
   1036         destLength=-1;
   1037         errorCode=U_ZERO_ERROR;
   1038         pDest=u_strFromUTF8Lenient(NULL, 0, &destLength, pb, -1, &errorCode);
   1039         if (errorCode!= (destLength0==0 ? U_STRING_NOT_TERMINATED_WARNING : U_BUFFER_OVERFLOW_ERROR) ||
   1040             pDest!=NULL || dest[0]!=0x1234 || destLength!=destLength0
   1041         ) {
   1042             log_err("u_strFromUTF8Lenient(%d preflighting with NUL-termination) failed\n", number);
   1043         }
   1044 
   1045         /* preflighting/some capacity with NUL-termination */
   1046         if(srcLength>0) {
   1047             dest[destLength0-1]=0x1234;
   1048             destLength=-1;
   1049             errorCode=U_ZERO_ERROR;
   1050             pDest=u_strFromUTF8Lenient(dest, destLength0-1, &destLength, pb, -1, &errorCode);
   1051             if (errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1052                 dest[destLength0-1]!=0x1234 || destLength!=destLength0
   1053             ) {
   1054                 log_err("u_strFromUTF8Lenient(%d preflighting/some capacity with NUL-termination) failed\n", number);
   1055             }
   1056         }
   1057 
   1058         /* conversion with NUL-termination, much capacity */
   1059         dest[0]=dest[destLength0]=0x1234;
   1060         destLength=-1;
   1061         errorCode=U_ZERO_ERROR;
   1062         pDest=u_strFromUTF8Lenient(dest, UPRV_LENGTHOF(dest), &destLength, pb, -1, &errorCode);
   1063         if (errorCode!=U_ZERO_ERROR ||
   1064             pDest!=dest || dest[destLength0]!=0 ||
   1065             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
   1066         ) {
   1067             log_err("u_strFromUTF8Lenient(%d conversion with NUL-termination, much capacity) failed\n", number);
   1068         }
   1069 
   1070         /* conversion with NUL-termination, exact capacity */
   1071         dest[0]=dest[destLength0]=0x1234;
   1072         destLength=-1;
   1073         errorCode=U_ZERO_ERROR;
   1074         pDest=u_strFromUTF8Lenient(dest, destLength0, &destLength, pb, -1, &errorCode);
   1075         if (errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
   1076             pDest!=dest || dest[destLength0]!=0x1234 ||
   1077             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
   1078         ) {
   1079             log_err("u_strFromUTF8Lenient(%d conversion with NUL-termination, exact capacity) failed\n", number);
   1080         }
   1081 
   1082         /* preflighting with length */
   1083         dest[0]=0x1234;
   1084         destLength=-1;
   1085         errorCode=U_ZERO_ERROR;
   1086         pDest=u_strFromUTF8Lenient(NULL, 0, &destLength, pb, srcLength, &errorCode);
   1087         if (errorCode!= (destLength0==0 ? U_STRING_NOT_TERMINATED_WARNING : U_BUFFER_OVERFLOW_ERROR) ||
   1088             pDest!=NULL || dest[0]!=0x1234 || destLength!=srcLength
   1089         ) {
   1090             log_err("u_strFromUTF8Lenient(%d preflighting with length) failed\n", number);
   1091         }
   1092 
   1093         /* preflighting/some capacity with length */
   1094         if(srcLength>0) {
   1095             dest[srcLength-1]=0x1234;
   1096             destLength=-1;
   1097             errorCode=U_ZERO_ERROR;
   1098             pDest=u_strFromUTF8Lenient(dest, srcLength-1, &destLength, pb, srcLength, &errorCode);
   1099             if (errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1100                 dest[srcLength-1]!=0x1234 || destLength!=srcLength
   1101             ) {
   1102                 log_err("u_strFromUTF8Lenient(%d preflighting/some capacity with length) failed\n", number);
   1103             }
   1104         }
   1105 
   1106         /* conversion with length, much capacity */
   1107         dest[0]=dest[destLength0]=0x1234;
   1108         destLength=-1;
   1109         errorCode=U_ZERO_ERROR;
   1110         pDest=u_strFromUTF8Lenient(dest, UPRV_LENGTHOF(dest), &destLength, pb, srcLength, &errorCode);
   1111         if (errorCode!=U_ZERO_ERROR ||
   1112             pDest!=dest || dest[destLength0]!=0 ||
   1113             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
   1114         ) {
   1115             log_err("u_strFromUTF8Lenient(%d conversion with length, much capacity) failed\n", number);
   1116         }
   1117 
   1118         /* conversion with length, srcLength capacity */
   1119         dest[0]=dest[srcLength]=dest[destLength0]=0x1234;
   1120         destLength=-1;
   1121         errorCode=U_ZERO_ERROR;
   1122         pDest=u_strFromUTF8Lenient(dest, srcLength, &destLength, pb, srcLength, &errorCode);
   1123         if(srcLength==destLength0) {
   1124             if (errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
   1125                 pDest!=dest || dest[destLength0]!=0x1234 ||
   1126                 destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
   1127             ) {
   1128                 log_err("u_strFromUTF8Lenient(%d conversion with length, srcLength capacity/not terminated) failed\n", number);
   1129             }
   1130         } else {
   1131             if (errorCode!=U_ZERO_ERROR ||
   1132                 pDest!=dest || dest[destLength0]!=0 ||
   1133                 destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
   1134             ) {
   1135                 log_err("u_strFromUTF8Lenient(%d conversion with length, srcLength capacity/terminated) failed\n", number);
   1136             }
   1137         }
   1138     }
   1139 }
   1140 
   1141 static const uint16_t src16j[] = {
   1142     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
   1143     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
   1144     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
   1145     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
   1146     0x0000,
   1147     /* Test only ASCII */
   1148 
   1149 };
   1150 static const uint16_t src16WithNulls[] = {
   1151     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0000,
   1152     0x0048, 0x0049, 0x004A, 0x000D, 0x000A, 0x0000,
   1153     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0000,
   1154     0x0050, 0x0051, 0x0052, 0x000D, 0x000A, 0x0000,
   1155     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0000,
   1156     0x0058, 0x0059, 0x005A, 0x000D, 0x000A, 0x0000,
   1157     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0000,
   1158     0x0058, 0x0059, 0x005A, 0x000D, 0x000A, 0x0000,
   1159     /* test only ASCII */
   1160     /*
   1161     0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD,
   1162     0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
   1163     0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1,
   1164     0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB,
   1165     0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5,
   1166     0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
   1167     0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
   1168     0x0054, 0x0000 */
   1169 
   1170 };
   1171 static void Test_UChar_WCHART_API(void){
   1172 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
   1173     UErrorCode err = U_ZERO_ERROR;
   1174     const UChar* uSrc = src16j;
   1175     int32_t uSrcLen = sizeof(src16j)/2;
   1176     wchar_t* wDest = NULL;
   1177     int32_t wDestLen = 0;
   1178     int32_t reqLen= 0 ;
   1179     UBool failed = FALSE;
   1180     UChar* uDest = NULL;
   1181     int32_t uDestLen = 0;
   1182     int i =0;
   1183     {
   1184         /* Bad UErrorCode arguments. Make sure that the API doesn't crash, and that Purify doesn't complain. */
   1185         if (u_strFromWCS(NULL,0,NULL,NULL,0,NULL) != NULL) {
   1186             log_err("u_strFromWCS() should return NULL with a bad argument\n");
   1187         }
   1188         if (u_strToWCS(NULL,0,NULL,NULL,0,NULL) != NULL) {
   1189             log_err("u_strToWCS() should return NULL with a bad argument\n");
   1190         }
   1191 
   1192         /* NULL source & destination. */
   1193         err = U_ZERO_ERROR;
   1194         u_strFromWCS(NULL,0,NULL,NULL,0,&err);
   1195         if (err != U_STRING_NOT_TERMINATED_WARNING) {
   1196             log_err("u_strFromWCS(NULL, NULL) failed. Error: %s \n", u_errorName(err));
   1197         }
   1198         err = U_ZERO_ERROR;
   1199         u_strToWCS(NULL,0,NULL,NULL,0,&err);
   1200         if (err != U_STRING_NOT_TERMINATED_WARNING) {
   1201             log_err("u_strToWCS(NULL, NULL) failed. Error: %s \n", u_errorName(err));
   1202         }
   1203         err = U_ZERO_ERROR;
   1204 
   1205         /* pre-flight*/
   1206         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
   1207 
   1208         if(err == U_BUFFER_OVERFLOW_ERROR){
   1209             err=U_ZERO_ERROR;
   1210             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
   1211             wDestLen = reqLen+1;
   1212             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
   1213         }
   1214 
   1215         /* pre-flight */
   1216         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
   1217 
   1218 
   1219         if(err == U_BUFFER_OVERFLOW_ERROR){
   1220             err =U_ZERO_ERROR;
   1221             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
   1222             uDestLen = reqLen + 1;
   1223             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
   1224         }else if(U_FAILURE(err)){
   1225 
   1226             log_err("u_strFromWCS() failed. Error: %s \n", u_errorName(err));
   1227             return;
   1228         }
   1229 
   1230         for(i=0; i< uSrcLen; i++){
   1231             if(uDest[i] != src16j[i]){
   1232                 log_verbose("u_str*WCS() failed for unterminated string expected: \\u%04X got: \\u%04X at index: %i \n", src16j[i] ,uDest[i],i);
   1233                 failed =TRUE;
   1234             }
   1235         }
   1236 
   1237         if(U_FAILURE(err)){
   1238             failed = TRUE;
   1239         }
   1240         if(failed){
   1241             log_err("u_strToWCS() failed \n");
   1242         }
   1243         free(wDest);
   1244         free(uDest);
   1245 
   1246 
   1247         /* test with embeded nulls */
   1248         uSrc = src16WithNulls;
   1249         uSrcLen = sizeof(src16WithNulls)/2;
   1250         wDestLen =0;
   1251         uDestLen =0;
   1252         wDest = NULL;
   1253         uDest = NULL;
   1254         /* pre-flight*/
   1255         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
   1256 
   1257         if(err == U_BUFFER_OVERFLOW_ERROR){
   1258             err=U_ZERO_ERROR;
   1259             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
   1260             wDestLen = reqLen+1;
   1261             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
   1262         }
   1263 
   1264         /* pre-flight */
   1265         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
   1266 
   1267         if(err == U_BUFFER_OVERFLOW_ERROR){
   1268             err =U_ZERO_ERROR;
   1269             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
   1270             uDestLen = reqLen + 1;
   1271             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
   1272         }
   1273 
   1274         if(!U_FAILURE(err)) {
   1275          for(i=0; i< uSrcLen; i++){
   1276             if(uDest[i] != src16WithNulls[i]){
   1277                 log_verbose("u_str*WCS() failed for string with nulls expected: \\u%04X got: \\u%04X at index: %i \n", src16WithNulls[i] ,uDest[i],i);
   1278                 failed =TRUE;
   1279             }
   1280          }
   1281         }
   1282 
   1283         if(U_FAILURE(err)){
   1284             failed = TRUE;
   1285         }
   1286         if(failed){
   1287             log_err("u_strToWCS() failed \n");
   1288         }
   1289         free(wDest);
   1290         free(uDest);
   1291 
   1292     }
   1293 
   1294     {
   1295 
   1296         uSrc = src16j;
   1297         uSrcLen = sizeof(src16j)/2;
   1298         wDestLen =0;
   1299         uDestLen =0;
   1300         wDest = NULL;
   1301         uDest = NULL;
   1302         wDestLen = 0;
   1303         /* pre-flight*/
   1304         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&err);
   1305 
   1306         if(err == U_BUFFER_OVERFLOW_ERROR){
   1307             err=U_ZERO_ERROR;
   1308             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
   1309             wDestLen = reqLen+1;
   1310             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&err);
   1311         }
   1312         uDestLen = 0;
   1313         /* pre-flight */
   1314         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&err);
   1315 
   1316         if(err == U_BUFFER_OVERFLOW_ERROR){
   1317             err =U_ZERO_ERROR;
   1318             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
   1319             uDestLen = reqLen + 1;
   1320             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&err);
   1321         }
   1322 
   1323 
   1324         if(!U_FAILURE(err)) {
   1325          for(i=0; i< uSrcLen; i++){
   1326             if(uDest[i] != src16j[i]){
   1327                 log_verbose("u_str*WCS() failed for null terminated string expected: \\u%04X got: \\u%04X at index: %i \n", src16j[i] ,uDest[i],i);
   1328                 failed =TRUE;
   1329             }
   1330          }
   1331         }
   1332 
   1333         if(U_FAILURE(err)){
   1334             failed = TRUE;
   1335         }
   1336         if(failed){
   1337             log_err("u_strToWCS() failed \n");
   1338         }
   1339         free(wDest);
   1340         free(uDest);
   1341     }
   1342 
   1343     /*
   1344      * Test u_terminateWChars().
   1345      * All u_terminateXYZ() use the same implementation macro;
   1346      * we test this function to improve API coverage.
   1347      */
   1348     {
   1349         wchar_t buffer[10];
   1350 
   1351         err=U_ZERO_ERROR;
   1352         buffer[3]=0x20ac;
   1353         wDestLen=u_terminateWChars(buffer, UPRV_LENGTHOF(buffer), 3, &err);
   1354         if(err!=U_ZERO_ERROR || wDestLen!=3 || buffer[3]!=0) {
   1355             log_err("u_terminateWChars(buffer, all, 3, zero) failed: %s length %d [3]==U+%04x\n",
   1356                     u_errorName(err), wDestLen, buffer[3]);
   1357         }
   1358 
   1359         err=U_ZERO_ERROR;
   1360         buffer[3]=0x20ac;
   1361         wDestLen=u_terminateWChars(buffer, 3, 3, &err);
   1362         if(err!=U_STRING_NOT_TERMINATED_WARNING || wDestLen!=3 || buffer[3]!=0x20ac) {
   1363             log_err("u_terminateWChars(buffer, 3, 3, zero) failed: %s length %d [3]==U+%04x\n",
   1364                     u_errorName(err), wDestLen, buffer[3]);
   1365         }
   1366 
   1367         err=U_STRING_NOT_TERMINATED_WARNING;
   1368         buffer[3]=0x20ac;
   1369         wDestLen=u_terminateWChars(buffer, UPRV_LENGTHOF(buffer), 3, &err);
   1370         if(err!=U_ZERO_ERROR || wDestLen!=3 || buffer[3]!=0) {
   1371             log_err("u_terminateWChars(buffer, all, 3, not-terminated) failed: %s length %d [3]==U+%04x\n",
   1372                     u_errorName(err), wDestLen, buffer[3]);
   1373         }
   1374 
   1375         err=U_ZERO_ERROR;
   1376         buffer[3]=0x20ac;
   1377         wDestLen=u_terminateWChars(buffer, 2, 3, &err);
   1378         if(err!=U_BUFFER_OVERFLOW_ERROR || wDestLen!=3 || buffer[3]!=0x20ac) {
   1379             log_err("u_terminateWChars(buffer, 2, 3, zero) failed: %s length %d [3]==U+%04x\n",
   1380                     u_errorName(err), wDestLen, buffer[3]);
   1381         }
   1382     }
   1383 #else
   1384     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
   1385 #endif
   1386 }
   1387 
   1388 static void Test_widestrs()
   1389 {
   1390 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
   1391         wchar_t ws[100];
   1392         UChar rts[100];
   1393         int32_t wcap = sizeof(ws) / sizeof(*ws);
   1394         int32_t wl;
   1395         int32_t rtcap = sizeof(rts) / sizeof(*rts);
   1396         int32_t rtl;
   1397         wchar_t *wcs;
   1398         UChar *cp;
   1399         const char *errname;
   1400         UChar ustr[] = {'h', 'e', 'l', 'l', 'o', 0};
   1401         int32_t ul = sizeof(ustr)/sizeof(*ustr) -1;
   1402         char astr[100];
   1403 
   1404         UErrorCode err;
   1405 
   1406         err = U_ZERO_ERROR;
   1407         wcs = u_strToWCS(ws, wcap, &wl, ustr, ul, &err);
   1408         if (U_FAILURE(err)) {
   1409                 errname = u_errorName(err);
   1410                 log_err("test_widestrs: u_strToWCS error: %s!\n",errname);
   1411         }
   1412         if(ul!=wl){
   1413             log_err("u_strToWCS: ustr = %s, ul = %d, ws = %S, wl = %d!\n", u_austrcpy(astr, ustr), ul, ws, wl);
   1414         }
   1415         err = U_ZERO_ERROR;
   1416         wl = (int32_t)uprv_wcslen(wcs);
   1417         cp = u_strFromWCS(rts, rtcap, &rtl, wcs, wl, &err);
   1418         (void)cp;    /* Suppress set but not used warning. */
   1419         if (U_FAILURE(err)) {
   1420                 errname = u_errorName(err);
   1421                 fprintf(stderr, "test_widestrs: ucnv_wcstombs error: %s!\n",errname);
   1422         }
   1423         if(wl != rtl){
   1424             log_err("u_strFromWCS: wcs = %S, wl = %d,rts = %s, rtl = %d!\n", wcs, wl, u_austrcpy(astr, rts), rtl);
   1425         }
   1426 #else
   1427     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
   1428 #endif
   1429 }
   1430 
   1431 static void
   1432 Test_WCHART_LongString(){
   1433 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
   1434     UErrorCode status = U_ZERO_ERROR;
   1435     const char* testdatapath=loadTestData(&status);
   1436     UResourceBundle *theBundle = ures_open(testdatapath, "testtypes", &status);
   1437     int32_t strLen =0;
   1438     const UChar* str = ures_getStringByKey(theBundle, "testinclude",&strLen,&status);
   1439     const UChar* uSrc = str;
   1440     int32_t uSrcLen = strLen;
   1441     int32_t wDestLen =0, reqLen=0, i=0;
   1442     int32_t uDestLen =0;
   1443     wchar_t* wDest = NULL;
   1444     UChar* uDest = NULL;
   1445     UBool failed = FALSE;
   1446 
   1447     log_verbose("Loaded string of %d UChars\n", uSrcLen);
   1448 
   1449     if(U_FAILURE(status)){
   1450         log_data_err("Could not get testinclude resource from testtypes bundle. Error: %s\n",u_errorName(status));
   1451         return;
   1452     }
   1453 
   1454     /* pre-flight*/
   1455     u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&status);
   1456 
   1457     if(status == U_BUFFER_OVERFLOW_ERROR){
   1458         status=U_ZERO_ERROR;
   1459         wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
   1460         wDestLen = reqLen+1;
   1461         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&status);
   1462         log_verbose("To %d*%d-byte wchar_ts\n", reqLen,sizeof(wchar_t));
   1463     }
   1464 
   1465     {
   1466       int j;
   1467       for(j=0;j>=0&&j<reqLen;j++) {
   1468         if(wDest[j]!=uSrc[j]) {
   1469           log_verbose("Diff %04X vs %04X @ %d\n", wDest[j],uSrc[j],j);
   1470           break;
   1471         }
   1472       }
   1473     }
   1474 
   1475     uDestLen = 0;
   1476     /* pre-flight */
   1477     u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&status);
   1478     if(status == U_BUFFER_OVERFLOW_ERROR){
   1479         status =U_ZERO_ERROR;
   1480         uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
   1481         u_memset(uDest,0xFFFF,reqLen+1);
   1482         uDestLen = reqLen + 1;
   1483         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&status);
   1484         log_verbose("Back to %d UChars\n", reqLen);
   1485     }
   1486 #if defined(U_WCHAR_IS_UTF16)
   1487     log_verbose("U_WCHAR_IS_UTF16\n");
   1488 #elif defined(U_WCHAR_IS_UTF32)
   1489     log_verbose("U_WCHAR_IS_UTF32\n");
   1490 #else
   1491     log_verbose("U_WCHAR_IS_idunno (not UTF)\n");
   1492 #endif
   1493 
   1494     if(reqLen!=uSrcLen) {
   1495         log_err("Error: dest len is %d but expected src len %d\n", reqLen, uSrcLen);
   1496     }
   1497 
   1498     for(i=0; i< uSrcLen; i++){
   1499         if(uDest[i] != str[i]){
   1500             log_verbose("u_str*WCS() failed for null terminated string expected: \\u%04X got: \\u%04X at index: %i \n", str[i], uDest[i],i);
   1501             failed =TRUE;
   1502         }
   1503     }
   1504 
   1505     if(U_FAILURE(status)){
   1506         failed = TRUE;
   1507     }
   1508     if(failed){
   1509         log_err("u_strToWCS() failed \n");
   1510     }
   1511     free(wDest);
   1512     free(uDest);
   1513     /* close the bundle */
   1514     ures_close(theBundle);
   1515 #else
   1516     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
   1517 #endif
   1518 }
   1519 
   1520 static void Test_strToJavaModifiedUTF8() {
   1521     static const UChar src[]={
   1522         0x61, 0x62, 0x63, 0xe1, 0xe2, 0xe3,
   1523         0xe01, 0xe02, 0xe03, 0xe001, 0xe002, 0xe003,
   1524         0xd800, 0xdc00, 0xdc00, 0xd800, 0,
   1525         0xdbff, 0xdfff,
   1526         0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0xed, 0xe0e, 0x6f
   1527     };
   1528     static const uint8_t expected[]={
   1529         0x61, 0x62, 0x63, 0xc3, 0xa1, 0xc3, 0xa2, 0xc3, 0xa3,
   1530         0xe0, 0xb8, 0x81, 0xe0, 0xb8, 0x82, 0xe0, 0xb8, 0x83,
   1531         0xee, 0x80, 0x81, 0xee, 0x80, 0x82, 0xee, 0x80, 0x83,
   1532         0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80, 0xed, 0xb0, 0x80, 0xed, 0xa0, 0x80, 0xc0, 0x80,
   1533         0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf,
   1534         0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0xc3, 0xad, 0xe0, 0xb8, 0x8e, 0x6f
   1535     };
   1536     static const UChar shortSrc[]={
   1537         0xe01, 0xe1, 0x61
   1538     };
   1539     static const uint8_t shortExpected[]={
   1540         0xe0, 0xb8, 0x81, 0xc3, 0xa1, 0x61
   1541     };
   1542     static const UChar asciiNul[]={
   1543         0x61, 0x62, 0x63, 0
   1544     };
   1545     static const uint8_t asciiNulExpected[]={
   1546         0x61, 0x62, 0x63
   1547     };
   1548     char dest[200];
   1549     char *p;
   1550     int32_t length, expectedTerminatedLength;
   1551     UErrorCode errorCode;
   1552 
   1553     expectedTerminatedLength=(int32_t)(strstr((const char *)expected, "\xc0\x80")-
   1554                                        (const char *)expected);
   1555 
   1556     errorCode=U_ZERO_ERROR;
   1557     length=-5;
   1558     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), &length,
   1559                               src, UPRV_LENGTHOF(src), &errorCode);
   1560     if( U_FAILURE(errorCode) || p!=dest ||
   1561         length!=UPRV_LENGTHOF(expected) || 0!=memcmp(dest, expected, length) ||
   1562         dest[length]!=0
   1563     ) {
   1564         log_err("u_strToJavaModifiedUTF8(normal) failed - %s\n", u_errorName(errorCode));
   1565     }
   1566     memset(dest, 0xff, sizeof(dest));
   1567     errorCode=U_ZERO_ERROR;
   1568     length=-5;
   1569     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), NULL,
   1570                               src, UPRV_LENGTHOF(src), &errorCode);
   1571     if( U_FAILURE(errorCode) || p!=dest ||
   1572         0!=memcmp(dest, expected, UPRV_LENGTHOF(expected)) ||
   1573         dest[UPRV_LENGTHOF(expected)]!=0
   1574     ) {
   1575         log_err("u_strToJavaModifiedUTF8(normal, pLength=NULL) failed - %s\n", u_errorName(errorCode));
   1576     }
   1577     memset(dest, 0xff, sizeof(dest));
   1578     errorCode=U_ZERO_ERROR;
   1579     length=-5;
   1580     p=u_strToJavaModifiedUTF8(dest, UPRV_LENGTHOF(expected), &length,
   1581                               src, UPRV_LENGTHOF(src), &errorCode);
   1582     if( errorCode!=U_STRING_NOT_TERMINATED_WARNING || p!=dest ||
   1583         length!=UPRV_LENGTHOF(expected) || 0!=memcmp(dest, expected, length) ||
   1584         dest[length]!=(char)0xff
   1585     ) {
   1586         log_err("u_strToJavaModifiedUTF8(tight) failed - %s\n", u_errorName(errorCode));
   1587     }
   1588     memset(dest, 0xff, sizeof(dest));
   1589     errorCode=U_ZERO_ERROR;
   1590     length=-5;
   1591     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), &length, src, -1, &errorCode);
   1592     if( U_FAILURE(errorCode) || p!=dest ||
   1593         length!=expectedTerminatedLength || 0!=memcmp(dest, expected, length) ||
   1594         dest[length]!=0
   1595     ) {
   1596         log_err("u_strToJavaModifiedUTF8(NUL-terminated) failed - %s\n", u_errorName(errorCode));
   1597     }
   1598     memset(dest, 0xff, sizeof(dest));
   1599     errorCode=U_ZERO_ERROR;
   1600     length=-5;
   1601     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), NULL, src, -1, &errorCode);
   1602     if( U_FAILURE(errorCode) || p!=dest ||
   1603         0!=memcmp(dest, expected, expectedTerminatedLength) ||
   1604         dest[expectedTerminatedLength]!=0
   1605     ) {
   1606         log_err("u_strToJavaModifiedUTF8(NUL-terminated, pLength=NULL) failed - %s\n", u_errorName(errorCode));
   1607     }
   1608     memset(dest, 0xff, sizeof(dest));
   1609     errorCode=U_ZERO_ERROR;
   1610     length=-5;
   1611     p=u_strToJavaModifiedUTF8(dest, UPRV_LENGTHOF(expected)/2, &length,
   1612                               src, UPRV_LENGTHOF(src), &errorCode);
   1613     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1614         length!=UPRV_LENGTHOF(expected) || dest[UPRV_LENGTHOF(expected)/2]!=(char)0xff
   1615     ) {
   1616         log_err("u_strToJavaModifiedUTF8(overflow) failed - %s\n", u_errorName(errorCode));
   1617     }
   1618     memset(dest, 0xff, sizeof(dest));
   1619     errorCode=U_ZERO_ERROR;
   1620     length=-5;
   1621     p=u_strToJavaModifiedUTF8(NULL, 0, &length,
   1622                               src, UPRV_LENGTHOF(src), &errorCode);
   1623     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1624         length!=UPRV_LENGTHOF(expected) || dest[0]!=(char)0xff
   1625     ) {
   1626         log_err("u_strToJavaModifiedUTF8(pure preflighting) failed - %s\n", u_errorName(errorCode));
   1627     }
   1628     memset(dest, 0xff, sizeof(dest));
   1629     errorCode=U_ZERO_ERROR;
   1630     length=-5;
   1631     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), &length,
   1632                               shortSrc, UPRV_LENGTHOF(shortSrc), &errorCode);
   1633     if( U_FAILURE(errorCode) || p!=dest ||
   1634         length!=UPRV_LENGTHOF(shortExpected) || 0!=memcmp(dest, shortExpected, length) ||
   1635         dest[length]!=0
   1636     ) {
   1637         log_err("u_strToJavaModifiedUTF8(short) failed - %s\n", u_errorName(errorCode));
   1638     }
   1639     memset(dest, 0xff, sizeof(dest));
   1640     errorCode=U_ZERO_ERROR;
   1641     length=-5;
   1642     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), &length,
   1643                               asciiNul, -1, &errorCode);
   1644     if( U_FAILURE(errorCode) || p!=dest ||
   1645         length!=UPRV_LENGTHOF(asciiNulExpected) || 0!=memcmp(dest, asciiNulExpected, length) ||
   1646         dest[length]!=0
   1647     ) {
   1648         log_err("u_strToJavaModifiedUTF8(asciiNul) failed - %s\n", u_errorName(errorCode));
   1649     }
   1650     memset(dest, 0xff, sizeof(dest));
   1651     errorCode=U_ZERO_ERROR;
   1652     length=-5;
   1653     p=u_strToJavaModifiedUTF8(dest, (int32_t)sizeof(dest), &length,
   1654                               NULL, 0, &errorCode);
   1655     if( U_FAILURE(errorCode) || p!=dest ||
   1656         length!=0 || dest[0]!=0
   1657     ) {
   1658         log_err("u_strToJavaModifiedUTF8(empty) failed - %s\n", u_errorName(errorCode));
   1659     }
   1660 
   1661     /* illegal arguments */
   1662     memset(dest, 0xff, sizeof(dest));
   1663     errorCode=U_ZERO_ERROR;
   1664     length=-5;
   1665     p=u_strToJavaModifiedUTF8(NULL, sizeof(dest), &length,
   1666                               src, UPRV_LENGTHOF(src), &errorCode);
   1667     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=(char)0xff) {
   1668         log_err("u_strToJavaModifiedUTF8(dest=NULL) failed - %s\n", u_errorName(errorCode));
   1669     }
   1670     memset(dest, 0xff, sizeof(dest));
   1671     errorCode=U_ZERO_ERROR;
   1672     length=-5;
   1673     p=u_strToJavaModifiedUTF8(dest, -1, &length,
   1674                               src, UPRV_LENGTHOF(src), &errorCode);
   1675     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=(char)0xff) {
   1676         log_err("u_strToJavaModifiedUTF8(destCapacity<0) failed - %s\n", u_errorName(errorCode));
   1677     }
   1678     memset(dest, 0xff, sizeof(dest));
   1679     errorCode=U_ZERO_ERROR;
   1680     length=-5;
   1681     p=u_strToJavaModifiedUTF8(dest, sizeof(dest), &length,
   1682                               NULL, UPRV_LENGTHOF(src), &errorCode);
   1683     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=(char)0xff) {
   1684         log_err("u_strToJavaModifiedUTF8(src=NULL) failed - %s\n", u_errorName(errorCode));
   1685     }
   1686     memset(dest, 0xff, sizeof(dest));
   1687     errorCode=U_ZERO_ERROR;
   1688     length=-5;
   1689     p=u_strToJavaModifiedUTF8(dest, sizeof(dest), &length,
   1690                               NULL, -1, &errorCode);
   1691     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=(char)0xff) {
   1692         log_err("u_strToJavaModifiedUTF8(src=NULL, srcLength<0) failed - %s\n", u_errorName(errorCode));
   1693     }
   1694 }
   1695 
   1696 static void Test_strFromJavaModifiedUTF8() {
   1697     static const uint8_t src[]={
   1698         0x61, 0x62, 0x63, 0xc3, 0xa1, 0xc3, 0xa2, 0xc3, 0xa3,
   1699         0xe0, 0xb8, 0x81, 0xe0, 0xb8, 0x82, 0xe0, 0xb8, 0x83,
   1700         0xee, 0x80, 0x81, 0xee, 0x80, 0x82, 0xee, 0x80, 0x83,
   1701         0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80, 0xed, 0xb0, 0x80, 0xed, 0xa0, 0x80, 0,
   1702         0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf,
   1703         0x81, 0xc0, 0xe0, 0xb8, 0xf0, 0x90, 0x80, 0x80,  /* invalid sequences */
   1704         0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
   1705         0xe0, 0x81, 0xac, 0xe0, 0x83, 0xad,  /* non-shortest forms are allowed */
   1706         0xe0, 0xb8, 0x8e, 0x6f
   1707     };
   1708     static const UChar expected[]={
   1709         0x61, 0x62, 0x63, 0xe1, 0xe2, 0xe3,
   1710         0xe01, 0xe02, 0xe03, 0xe001, 0xe002, 0xe003,
   1711         0xd800, 0xdc00, 0xdc00, 0xd800, 0,
   1712         0xdbff, 0xdfff,
   1713         0xfffd, 0xfffd, 0xfffd, 0xfffd,
   1714         0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
   1715         0x6c, 0xed,
   1716         0xe0e, 0x6f
   1717     };
   1718     static const uint8_t shortSrc[]={
   1719         0xe0, 0xb8, 0x81, 0xc3, 0xa1, 0x61
   1720     };
   1721     static const UChar shortExpected[]={
   1722         0xe01, 0xe1, 0x61
   1723     };
   1724     static const uint8_t asciiNul[]={
   1725         0x61, 0x62, 0x63, 0
   1726     };
   1727     static const UChar asciiNulExpected[]={
   1728         0x61, 0x62, 0x63
   1729     };
   1730     static const uint8_t invalid[]={
   1731         0x81, 0xc0, 0xe0, 0xb8, 0xf0, 0x90, 0x80, 0x80
   1732     };
   1733     static const UChar invalidExpectedFFFD[]={
   1734         0xfffd, 0xfffd, 0xfffd, 0xfffd
   1735     };
   1736     static const UChar invalidExpected50000[]={
   1737         0xd900, 0xdc00, 0xd900, 0xdc00, 0xd900, 0xdc00, 0xd900, 0xdc00
   1738     };
   1739     UChar dest[200];
   1740     UChar *p;
   1741     int32_t length, expectedTerminatedLength;
   1742     int32_t numSubstitutions;
   1743     UErrorCode errorCode;
   1744 
   1745     expectedTerminatedLength=(int32_t)(u_strchr(expected, 0)-expected);
   1746 
   1747     errorCode=U_ZERO_ERROR;
   1748     length=numSubstitutions=-5;
   1749     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1750                                        (const char *)src, UPRV_LENGTHOF(src),
   1751                                        0xfffd, &numSubstitutions, &errorCode);
   1752     if( U_FAILURE(errorCode) || p!=dest ||
   1753         length!=UPRV_LENGTHOF(expected) || 0!=memcmp(dest, expected, length) ||
   1754         dest[length]!=0 ||
   1755         numSubstitutions!=UPRV_LENGTHOF(invalidExpectedFFFD)
   1756     ) {
   1757         log_err("u_strFromJavaModifiedUTF8WithSub(normal) failed - %s\n", u_errorName(errorCode));
   1758     }
   1759     memset(dest, 0xff, sizeof(dest));
   1760     errorCode=U_ZERO_ERROR;
   1761     length=numSubstitutions=-5;
   1762     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), NULL,
   1763                                        (const char *)src, UPRV_LENGTHOF(src),
   1764                                        0xfffd, &numSubstitutions, &errorCode);
   1765     if( U_FAILURE(errorCode) || p!=dest ||
   1766         0!=memcmp(dest, expected, UPRV_LENGTHOF(expected)) ||
   1767         dest[UPRV_LENGTHOF(expected)]!=0 ||
   1768         numSubstitutions!=UPRV_LENGTHOF(invalidExpectedFFFD)
   1769     ) {
   1770         log_err("u_strFromJavaModifiedUTF8WithSub(normal, pLength=NULL) failed - %s\n", u_errorName(errorCode));
   1771     }
   1772     memset(dest, 0xff, sizeof(dest));
   1773     errorCode=U_ZERO_ERROR;
   1774     length=numSubstitutions=-5;
   1775     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1776                                        (const char *)src, UPRV_LENGTHOF(src),
   1777                                        0xfffd, NULL, &errorCode);
   1778     if( U_FAILURE(errorCode) || p!=dest ||
   1779         length!=UPRV_LENGTHOF(expected) || 0!=memcmp(dest, expected, length) ||
   1780         dest[length]!=0
   1781     ) {
   1782         log_err("u_strFromJavaModifiedUTF8WithSub(normal, pNumSubstitutions=NULL) failed - %s\n", u_errorName(errorCode));
   1783     }
   1784     memset(dest, 0xff, sizeof(dest));
   1785     errorCode=U_ZERO_ERROR;
   1786     length=numSubstitutions=-5;
   1787     p=u_strFromJavaModifiedUTF8WithSub(dest, UPRV_LENGTHOF(expected), &length,
   1788                                        (const char *)src, UPRV_LENGTHOF(src),
   1789                                        0xfffd, &numSubstitutions, &errorCode);
   1790     if( errorCode!=U_STRING_NOT_TERMINATED_WARNING || p!=dest ||
   1791         length!=UPRV_LENGTHOF(expected) || 0!=memcmp(dest, expected, length) ||
   1792         dest[length]!=0xffff ||
   1793         numSubstitutions!=UPRV_LENGTHOF(invalidExpectedFFFD)
   1794     ) {
   1795         log_err("u_strFromJavaModifiedUTF8WithSub(tight) failed - %s\n", u_errorName(errorCode));
   1796     }
   1797     memset(dest, 0xff, sizeof(dest));
   1798     errorCode=U_ZERO_ERROR;
   1799     length=numSubstitutions=-5;
   1800     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1801                                        (const char *)src, -1,
   1802                                        0xfffd, &numSubstitutions, &errorCode);
   1803     if( U_FAILURE(errorCode) || p!=dest ||
   1804         length!=expectedTerminatedLength || 0!=memcmp(dest, expected, length) ||
   1805         dest[length]!=0 ||
   1806         numSubstitutions!=0
   1807     ) {
   1808         log_err("u_strFromJavaModifiedUTF8WithSub(NUL-terminated) failed - %s\n", u_errorName(errorCode));
   1809     }
   1810     memset(dest, 0xff, sizeof(dest));
   1811     errorCode=U_ZERO_ERROR;
   1812     length=numSubstitutions=-5;
   1813     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), NULL,
   1814                                        (const char *)src, -1,
   1815                                        0xfffd, &numSubstitutions, &errorCode);
   1816     if( U_FAILURE(errorCode) || p!=dest ||
   1817         0!=memcmp(dest, expected, expectedTerminatedLength) ||
   1818         dest[expectedTerminatedLength]!=0 ||
   1819         numSubstitutions!=0
   1820     ) {
   1821         log_err("u_strFromJavaModifiedUTF8WithSub(NUL-terminated, pLength=NULL) failed - %s\n", u_errorName(errorCode));
   1822     }
   1823     memset(dest, 0xff, sizeof(dest));
   1824     errorCode=U_ZERO_ERROR;
   1825     length=numSubstitutions=-5;
   1826     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1827                                        (const char *)src, -1,
   1828                                        0xfffd, NULL, &errorCode);
   1829     if( U_FAILURE(errorCode) || p!=dest ||
   1830         length!=expectedTerminatedLength || 0!=memcmp(dest, expected, length) ||
   1831         dest[length]!=0
   1832     ) {
   1833         log_err("u_strFromJavaModifiedUTF8WithSub(NUL-terminated, pNumSubstitutions=NULL) failed - %s\n", u_errorName(errorCode));
   1834     }
   1835     memset(dest, 0xff, sizeof(dest));
   1836     errorCode=U_ZERO_ERROR;
   1837     length=numSubstitutions=-5;
   1838     p=u_strFromJavaModifiedUTF8WithSub(dest, UPRV_LENGTHOF(expected)/2, &length,
   1839                                        (const char *)src, UPRV_LENGTHOF(src),
   1840                                        0xfffd, &numSubstitutions, &errorCode);
   1841     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1842         length!=UPRV_LENGTHOF(expected) || dest[UPRV_LENGTHOF(expected)/2]!=0xffff
   1843     ) {
   1844         log_err("u_strFromJavaModifiedUTF8WithSub(overflow) failed - %s\n", u_errorName(errorCode));
   1845     }
   1846     memset(dest, 0xff, sizeof(dest));
   1847     errorCode=U_ZERO_ERROR;
   1848     length=numSubstitutions=-5;
   1849     p=u_strFromJavaModifiedUTF8WithSub(NULL, 0, &length,
   1850                                        (const char *)src, UPRV_LENGTHOF(src),
   1851                                        0xfffd, &numSubstitutions, &errorCode);
   1852     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
   1853         length!=UPRV_LENGTHOF(expected) || dest[0]!=0xffff
   1854     ) {
   1855         log_err("u_strFromJavaModifiedUTF8WithSub(pure preflighting) failed - %s\n", u_errorName(errorCode));
   1856     }
   1857     memset(dest, 0xff, sizeof(dest));
   1858     errorCode=U_ZERO_ERROR;
   1859     length=numSubstitutions=-5;
   1860     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1861                                        (const char *)shortSrc, UPRV_LENGTHOF(shortSrc),
   1862                                        0xfffd, &numSubstitutions, &errorCode);
   1863     if( U_FAILURE(errorCode) || p!=dest ||
   1864         length!=UPRV_LENGTHOF(shortExpected) || 0!=memcmp(dest, shortExpected, length) ||
   1865         dest[length]!=0 ||
   1866         numSubstitutions!=0
   1867     ) {
   1868         log_err("u_strFromJavaModifiedUTF8WithSub(short) failed - %s\n", u_errorName(errorCode));
   1869     }
   1870     memset(dest, 0xff, sizeof(dest));
   1871     errorCode=U_ZERO_ERROR;
   1872     length=numSubstitutions=-5;
   1873     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1874                                        (const char *)asciiNul, -1,
   1875                                        0xfffd, &numSubstitutions, &errorCode);
   1876     if( U_FAILURE(errorCode) || p!=dest ||
   1877         length!=UPRV_LENGTHOF(asciiNulExpected) || 0!=memcmp(dest, asciiNulExpected, length) ||
   1878         dest[length]!=0 ||
   1879         numSubstitutions!=0
   1880     ) {
   1881         log_err("u_strFromJavaModifiedUTF8WithSub(asciiNul) failed - %s\n", u_errorName(errorCode));
   1882     }
   1883     memset(dest, 0xff, sizeof(dest));
   1884     errorCode=U_ZERO_ERROR;
   1885     length=numSubstitutions=-5;
   1886     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1887                                        NULL, 0, 0xfffd, &numSubstitutions, &errorCode);
   1888     if( U_FAILURE(errorCode) || p!=dest ||
   1889         length!=0 || dest[0]!=0 ||
   1890         numSubstitutions!=0
   1891     ) {
   1892         log_err("u_strFromJavaModifiedUTF8WithSub(empty) failed - %s\n", u_errorName(errorCode));
   1893     }
   1894     memset(dest, 0xff, sizeof(dest));
   1895     errorCode=U_ZERO_ERROR;
   1896     length=numSubstitutions=-5;
   1897     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1898                                        (const char *)invalid, UPRV_LENGTHOF(invalid),
   1899                                        0xfffd, &numSubstitutions, &errorCode);
   1900     if( U_FAILURE(errorCode) || p!=dest ||
   1901         length!=UPRV_LENGTHOF(invalidExpectedFFFD) || 0!=memcmp(dest, invalidExpectedFFFD, length) ||
   1902         dest[length]!=0 ||
   1903         numSubstitutions!=UPRV_LENGTHOF(invalidExpectedFFFD)
   1904     ) {
   1905         log_err("u_strFromJavaModifiedUTF8WithSub(invalid->fffd) failed - %s\n", u_errorName(errorCode));
   1906     }
   1907     memset(dest, 0xff, sizeof(dest));
   1908     errorCode=U_ZERO_ERROR;
   1909     length=numSubstitutions=-5;
   1910     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1911                                        (const char *)invalid, UPRV_LENGTHOF(invalid),
   1912                                        0x50000, &numSubstitutions, &errorCode);
   1913     if( U_FAILURE(errorCode) || p!=dest ||
   1914         length!=UPRV_LENGTHOF(invalidExpected50000) || 0!=memcmp(dest, invalidExpected50000, length) ||
   1915         dest[length]!=0 ||
   1916         numSubstitutions!=UPRV_LENGTHOF(invalidExpectedFFFD)  /* not ...50000 */
   1917     ) {
   1918         log_err("u_strFromJavaModifiedUTF8WithSub(invalid->50000) failed - %s\n", u_errorName(errorCode));
   1919     }
   1920     memset(dest, 0xff, sizeof(dest));
   1921     errorCode=U_ZERO_ERROR;
   1922     length=numSubstitutions=-5;
   1923     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1924                                        (const char *)invalid, UPRV_LENGTHOF(invalid),
   1925                                        U_SENTINEL, &numSubstitutions, &errorCode);
   1926     if(errorCode!=U_INVALID_CHAR_FOUND || dest[0]!=0xffff || numSubstitutions!=0) {
   1927         log_err("u_strFromJavaModifiedUTF8WithSub(invalid->error) failed - %s\n", u_errorName(errorCode));
   1928     }
   1929     memset(dest, 0xff, sizeof(dest));
   1930     errorCode=U_ZERO_ERROR;
   1931     length=numSubstitutions=-5;
   1932     p=u_strFromJavaModifiedUTF8WithSub(dest, (int32_t)sizeof(dest), &length,
   1933                                        (const char *)src, UPRV_LENGTHOF(src),
   1934                                        U_SENTINEL, &numSubstitutions, &errorCode);
   1935     if( errorCode!=U_INVALID_CHAR_FOUND ||
   1936         length>=UPRV_LENGTHOF(expected) || dest[UPRV_LENGTHOF(expected)-1]!=0xffff ||
   1937         numSubstitutions!=0
   1938     ) {
   1939         log_err("u_strFromJavaModifiedUTF8WithSub(normal->error) failed - %s\n", u_errorName(errorCode));
   1940     }
   1941 
   1942     /* illegal arguments */
   1943     memset(dest, 0xff, sizeof(dest));
   1944     errorCode=U_ZERO_ERROR;
   1945     length=numSubstitutions=-5;
   1946     p=u_strFromJavaModifiedUTF8WithSub(NULL, sizeof(dest), &length,
   1947                                        (const char *)src, UPRV_LENGTHOF(src),
   1948                                        0xfffd, &numSubstitutions, &errorCode);
   1949     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1950         log_err("u_strFromJavaModifiedUTF8WithSub(dest=NULL) failed - %s\n", u_errorName(errorCode));
   1951     }
   1952     memset(dest, 0xff, sizeof(dest));
   1953     errorCode=U_ZERO_ERROR;
   1954     length=numSubstitutions=-5;
   1955     p=u_strFromJavaModifiedUTF8WithSub(dest, -1, &length,
   1956                                        (const char *)src, UPRV_LENGTHOF(src),
   1957                                        0xfffd, &numSubstitutions, &errorCode);
   1958     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1959         log_err("u_strFromJavaModifiedUTF8WithSub(destCapacity<0) failed - %s\n", u_errorName(errorCode));
   1960     }
   1961     memset(dest, 0xff, sizeof(dest));
   1962     errorCode=U_ZERO_ERROR;
   1963     length=numSubstitutions=-5;
   1964     p=u_strFromJavaModifiedUTF8WithSub(dest, sizeof(dest), &length,
   1965                                        NULL, UPRV_LENGTHOF(src),
   1966                                        0xfffd, &numSubstitutions, &errorCode);
   1967     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1968         log_err("u_strFromJavaModifiedUTF8WithSub(src=NULL) failed - %s\n", u_errorName(errorCode));
   1969     }
   1970     memset(dest, 0xff, sizeof(dest));
   1971     errorCode=U_ZERO_ERROR;
   1972     length=numSubstitutions=-5;
   1973     p=u_strFromJavaModifiedUTF8WithSub(dest, sizeof(dest), &length,
   1974                                        NULL, -1, 0xfffd, &numSubstitutions, &errorCode);
   1975     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1976         log_err("u_strFromJavaModifiedUTF8WithSub(src=NULL, srcLength<0) failed - %s\n", u_errorName(errorCode));
   1977     }
   1978     memset(dest, 0xff, sizeof(dest));
   1979     errorCode=U_ZERO_ERROR;
   1980     length=numSubstitutions=-5;
   1981     p=u_strFromJavaModifiedUTF8WithSub(dest, sizeof(dest), &length,
   1982                                        (const char *)src, UPRV_LENGTHOF(src),
   1983                                        0x110000, &numSubstitutions, &errorCode);
   1984     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1985         log_err("u_strFromJavaModifiedUTF8WithSub(subchar=U_SENTINEL) failed - %s\n", u_errorName(errorCode));
   1986     }
   1987     memset(dest, 0xff, sizeof(dest));
   1988     errorCode=U_ZERO_ERROR;
   1989     length=numSubstitutions=-5;
   1990     p=u_strFromJavaModifiedUTF8WithSub(dest, sizeof(dest), &length,
   1991                                        (const char *)src, UPRV_LENGTHOF(src),
   1992                                        0xdfff, &numSubstitutions, &errorCode);
   1993     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0xffff) {
   1994         log_err("u_strFromJavaModifiedUTF8WithSub(subchar is surrogate) failed - %s\n", u_errorName(errorCode));
   1995     }
   1996 }
   1997 
   1998 /* test that string transformation functions permit NULL source pointer when source length==0 */
   1999 static void TestNullEmptySource() {
   2000     char dest8[4]={ 3, 3, 3, 3 };
   2001     UChar dest16[4]={ 3, 3, 3, 3 };
   2002     UChar32 dest32[4]={ 3, 3, 3, 3 };
   2003 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
   2004     wchar_t destW[4]={ 3, 3, 3, 3 };
   2005 #endif
   2006 
   2007     int32_t length;
   2008     UErrorCode errorCode;
   2009 
   2010     /* u_strFromXyz() */
   2011 
   2012     dest16[0]=3;
   2013     length=3;
   2014     errorCode=U_ZERO_ERROR;
   2015     u_strFromUTF8(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, &errorCode);
   2016     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2017         log_err("u_strFromUTF8(source=NULL, sourceLength=0) failed\n");
   2018     }
   2019 
   2020     dest16[0]=3;
   2021     length=3;
   2022     errorCode=U_ZERO_ERROR;
   2023     u_strFromUTF8WithSub(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, 0xfffd, NULL, &errorCode);
   2024     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2025         log_err("u_strFromUTF8WithSub(source=NULL, sourceLength=0) failed\n");
   2026     }
   2027 
   2028     dest16[0]=3;
   2029     length=3;
   2030     errorCode=U_ZERO_ERROR;
   2031     u_strFromUTF8Lenient(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, &errorCode);
   2032     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2033         log_err("u_strFromUTF8Lenient(source=NULL, sourceLength=0) failed\n");
   2034     }
   2035 
   2036     dest16[0]=3;
   2037     length=3;
   2038     errorCode=U_ZERO_ERROR;
   2039     u_strFromUTF32(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, &errorCode);
   2040     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2041         log_err("u_strFromUTF32(source=NULL, sourceLength=0) failed\n");
   2042     }
   2043 
   2044     dest16[0]=3;
   2045     length=3;
   2046     errorCode=U_ZERO_ERROR;
   2047     u_strFromUTF32WithSub(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, 0xfffd, NULL, &errorCode);
   2048     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2049         log_err("u_strFromUTF32WithSub(source=NULL, sourceLength=0) failed\n");
   2050     }
   2051 
   2052     dest16[0]=3;
   2053     length=3;
   2054     errorCode=U_ZERO_ERROR;
   2055     u_strFromJavaModifiedUTF8WithSub(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, 0xfffd, NULL, &errorCode);
   2056     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2057         log_err("u_strFromJavaModifiedUTF8WithSub(source=NULL, sourceLength=0) failed\n");
   2058     }
   2059 
   2060     /* u_strToXyz() */
   2061 
   2062     dest8[0]=3;
   2063     length=3;
   2064     errorCode=U_ZERO_ERROR;
   2065     u_strToUTF8(dest8, UPRV_LENGTHOF(dest8), &length, NULL, 0, &errorCode);
   2066     if(errorCode!=U_ZERO_ERROR || length!=0 || dest8[0]!=0 || dest8[1]!=3) {
   2067         log_err("u_strToUTF8(source=NULL, sourceLength=0) failed\n");
   2068     }
   2069 
   2070     dest8[0]=3;
   2071     length=3;
   2072     errorCode=U_ZERO_ERROR;
   2073     u_strToUTF8WithSub(dest8, UPRV_LENGTHOF(dest8), &length, NULL, 0, 0xfffd, NULL, &errorCode);
   2074     if(errorCode!=U_ZERO_ERROR || length!=0 || dest8[0]!=0 || dest8[1]!=3) {
   2075         log_err("u_strToUTF8(source=NULL, sourceLength=0) failed\n");
   2076     }
   2077 
   2078     dest32[0]=3;
   2079     length=3;
   2080     errorCode=U_ZERO_ERROR;
   2081     u_strToUTF32(dest32, UPRV_LENGTHOF(dest32), &length, NULL, 0, &errorCode);
   2082     if(errorCode!=U_ZERO_ERROR || length!=0 || dest32[0]!=0 || dest32[1]!=3) {
   2083         log_err("u_strToUTF32(source=NULL, sourceLength=0) failed\n");
   2084     }
   2085 
   2086     dest32[0]=3;
   2087     length=3;
   2088     errorCode=U_ZERO_ERROR;
   2089     u_strToUTF32WithSub(dest32, UPRV_LENGTHOF(dest32), &length, NULL, 0, 0xfffd, NULL, &errorCode);
   2090     if(errorCode!=U_ZERO_ERROR || length!=0 || dest32[0]!=0 || dest32[1]!=3) {
   2091         log_err("u_strToUTF32WithSub(source=NULL, sourceLength=0) failed\n");
   2092     }
   2093 
   2094     dest8[0]=3;
   2095     length=3;
   2096     errorCode=U_ZERO_ERROR;
   2097     u_strToJavaModifiedUTF8(dest8, UPRV_LENGTHOF(dest8), &length, NULL, 0, &errorCode);
   2098     if(errorCode!=U_ZERO_ERROR || length!=0 || dest8[0]!=0 || dest8[1]!=3) {
   2099         log_err("u_strToJavaModifiedUTF8(source=NULL, sourceLength=0) failed\n");
   2100     }
   2101 
   2102 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
   2103 
   2104     dest16[0]=3;
   2105     length=3;
   2106     errorCode=U_ZERO_ERROR;
   2107     u_strFromWCS(dest16, UPRV_LENGTHOF(dest16), &length, NULL, 0, &errorCode);
   2108     if(errorCode!=U_ZERO_ERROR || length!=0 || dest16[0]!=0 || dest16[1]!=3) {
   2109         log_err("u_strFromWCS(source=NULL, sourceLength=0) failed\n");
   2110     }
   2111 
   2112     destW[0]=3;
   2113     length=3;
   2114     errorCode=U_ZERO_ERROR;
   2115     u_strToWCS(destW, UPRV_LENGTHOF(destW), &length, NULL, 0, &errorCode);
   2116     if(errorCode!=U_ZERO_ERROR || length!=0 || destW[0]!=0 || destW[1]!=3) {
   2117         log_err("u_strToWCS(source=NULL, sourceLength=0) failed\n");
   2118     }
   2119 
   2120 #endif
   2121 }
   2122