icuSources/test/cintltst/custrtrn.c

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