icuSources/test/cintltst/custrtrn.c

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 2001-2008, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6 /********************************************************************************
   7 *
   8 * File custrtrn.C
   9 *
  10 * Modification History:
  11 *        Name                     Description
  12 *        Ram                      String transformations test
  13 *********************************************************************************
  14 */
  15 /****************************************************************************/
  16
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include "unicode/utypes.h"
  21 #include "unicode/ustring.h"
  22 #include "unicode/ures.h"
  23 #include "ustr_imp.h"
  24 #include "cintltst.h"
  25 #include "cmemory.h"
  26 #include "cstring.h"
  27 #include "cwchar.h"
  28
  29 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  30
  31 void addUCharTransformTest(TestNode** root);
  32
  33 static void Test_UChar_UTF32_API(void);
  34 static void Test_UChar_UTF8_API(void);
  35 static void Test_FromUTF8(void);
  36 static void Test_FromUTF8Lenient(void);
  37 static void Test_UChar_WCHART_API(void);
  38 static void Test_widestrs(void);
  39 static void Test_WCHART_LongString(void);
  40
  41 void
  42 addUCharTransformTest(TestNode** root)
  43 {
  44    addTest(root, &Test_UChar_UTF32_API, "custrtrn/Test_UChar_UTF32_API");
  45    addTest(root, &Test_UChar_UTF8_API, "custrtrn/Test_UChar_UTF8_API");
  46    addTest(root, &Test_FromUTF8, "custrtrn/Test_FromUTF8");
  47    addTest(root, &Test_FromUTF8Lenient, "custrtrn/Test_FromUTF8Lenient");
  48    addTest(root, &Test_UChar_WCHART_API,  "custrtrn/Test_UChar_WCHART_API");
  49    addTest(root, &Test_widestrs,  "custrtrn/Test_widestrs");
  50    addTest(root, &Test_WCHART_LongString, "custrtrn/Test_WCHART_LongString");
  51 }
  52
  53 static const UChar32 src32[]={
  54     0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
  55     0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
  56     0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
  57     0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
  58     0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
  59     0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
  60     0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
  61     0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
  62     0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
  63     0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
  64     0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
  65     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
  66     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
  67     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
  68     0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
  69     0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
  70     0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
  71     0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
  72     0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A,
  73     /* test non-BMP code points */
  74     0x0002A699,
  75     0x0002A69C, 0x0002A69D, 0x0002A69E, 0x0002A69F, 0x0002A6A0, 0x0002A6A5, 0x0002A6A6, 0x0002A6A7, 0x0002A6A8, 0x0002A6AB,
  76     0x0002A6AC, 0x0002A6AD, 0x0002A6AE, 0x0002A6AF, 0x0002A6B0, 0x0002A6B1, 0x0002A6B3, 0x0002A6B5, 0x0002A6B6, 0x0002A6B7,
  77     0x0002A6B8, 0x0002A6B9, 0x0002A6BA, 0x0002A6BB, 0x0002A6BC, 0x0002A6BD, 0x0002A6BE, 0x0002A6BF, 0x0002A6C0, 0x0002A6C1,
  78     0x0002A6C2, 0x0002A6C3, 0x0002A6C4, 0x0002A6C8, 0x0002A6CA, 0x0002A6CB, 0x0002A6CD, 0x0002A6CE, 0x0002A6CF, 0x0002A6D0,
  79     0x0002A6D1, 0x0002A6D2, 0x0002A6D3, 0x0002A6D4, 0x0002A6D5,
  80
  81     0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
  82     0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
  83     0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
  84     0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
  85     0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,0x0000
  86 };
  87
  88 static const UChar src16[] = {
  89     0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
  90     0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
  91     0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
  92     0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
  93     0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
  94     0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
  95     0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
  96     0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
  97     0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
  98     0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
  99     0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
 100     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
 101     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
 102     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
 103     0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
 104     0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
 105     0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
 106     0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
 107     0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A,
 108
 109     /* test non-BMP code points */
 110     0xD869, 0xDE99, 0xD869, 0xDE9C, 0xD869, 0xDE9D, 0xD869, 0xDE9E, 0xD869, 0xDE9F,
 111     0xD869, 0xDEA0, 0xD869, 0xDEA5, 0xD869, 0xDEA6, 0xD869, 0xDEA7, 0xD869, 0xDEA8,
 112     0xD869, 0xDEAB, 0xD869, 0xDEAC, 0xD869, 0xDEAD, 0xD869, 0xDEAE, 0xD869, 0xDEAF,
 113     0xD869, 0xDEB0, 0xD869, 0xDEB1, 0xD869, 0xDEB3, 0xD869, 0xDEB5, 0xD869, 0xDEB6,
 114     0xD869, 0xDEB7, 0xD869, 0xDEB8, 0xD869, 0xDEB9, 0xD869, 0xDEBA, 0xD869, 0xDEBB,
 115     0xD869, 0xDEBC, 0xD869, 0xDEBD, 0xD869, 0xDEBE, 0xD869, 0xDEBF, 0xD869, 0xDEC0,
 116     0xD869, 0xDEC1, 0xD869, 0xDEC2, 0xD869, 0xDEC3, 0xD869, 0xDEC4, 0xD869, 0xDEC8,
 117     0xD869, 0xDECA, 0xD869, 0xDECB, 0xD869, 0xDECD, 0xD869, 0xDECE, 0xD869, 0xDECF,
 118     0xD869, 0xDED0, 0xD869, 0xDED1, 0xD869, 0xDED2, 0xD869, 0xDED3, 0xD869, 0xDED4,
 119     0xD869, 0xDED5,
 120
 121     0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
 122     0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
 123     0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
 124     0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
 125     0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,0x0000
 126 };
 127
 128
 129 static void Test_UChar_UTF32_API(void){
 130
 131     UErrorCode err = U_ZERO_ERROR;
 132     UChar uTemp[1];
 133     UChar32 u32Temp[1];
 134     UChar* uTarget=uTemp;
 135     const UChar32* u32Src = src32;
 136     int32_t u32SrcLen = sizeof(src32)/4;
 137     int32_t uTargetLength = 0;
 138     int32_t uDestLen=0;
 139     const UChar* uSrc = src16;
 140     int32_t uSrcLen   = sizeof(src16)/2;
 141     UChar32* u32Target = u32Temp;
 142     uint32_t u32TargetLength =0;
 143     int32_t u32DestLen =0;
 144     UBool failed = FALSE;
 145     int i= 0;
 146     {
 147         /* preflight */
 148         u_strToUTF32(u32Target,u32TargetLength, &u32DestLen, uSrc, uSrcLen,&err);
 149         if(err == U_BUFFER_OVERFLOW_ERROR){
 150             err = U_ZERO_ERROR;
 151             u32Target = (UChar32*) malloc (sizeof(uint32_t) * (u32DestLen+1));
 152             u32TargetLength = u32DestLen+1;
 153
 154             u_strToUTF32(u32Target,u32TargetLength, &u32DestLen, uSrc, uSrcLen,&err);
 155         }
 156         else {
 157             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
 158         }
 159         failed = FALSE;
 160         /*for(i=0; i< u32DestLen; i++){
 161             printf("0x%08X, ",uTarget[i]);
 162             if(i%10==0){
 163                 printf("\n");
 164             }
 165         }*/
 166         for(i=0; i< u32SrcLen; i++){
 167             if(u32Target[i] != src32[i]){
 168                 log_verbose("u_strToUTF32() failed expected: \\U%08X got: \\U%08X at index: %i \n", src32[i], u32Target[i],i);
 169                 failed =TRUE;
 170             }
 171         }
 172         if(failed){
 173             log_err("u_strToUTF32() failed \n");
 174         }
 175
 176         /* preflight */
 177         u_strFromUTF32(uTarget,uTargetLength,&uDestLen,u32Src,u32SrcLen,&err);
 178         if(err == U_BUFFER_OVERFLOW_ERROR){
 179             err = U_ZERO_ERROR;
 180             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
 181             uTargetLength =  uDestLen+1;
 182             u_strFromUTF32(uTarget,uTargetLength,&uDestLen,u32Src,u32SrcLen,&err);
 183
 184         }
 185         /*for(i=0; i< uDestLen; i++){
 186             printf("0x%04X, ",uTarget[i]);
 187             if(i%10==0){
 188                 printf("\n");
 189             }
 190         }*/
 191
 192         for(i=0; i< uDestLen; i++){
 193             if(uTarget[i] != src16[i]){
 194                 log_verbose("u_strFromUTF32() failed expected: \\U%08X got: \\U%08X at index: %i \n", src16[i] ,uTarget[i],i);
 195                 failed =TRUE;
 196             }
 197         }
 198         if(failed){
 199             log_err("u_strToUTF32() failed \n");
 200         }
 201
 202         free(u32Target);
 203         free(uTarget);
 204     }
 205     {
 206         u32SrcLen = -1;
 207         uTargetLength = 0;
 208         uSrcLen =-1;
 209         u32TargetLength=0;
 210         failed = FALSE;
 211
 212        /* preflight */
 213         u_strToUTF32(NULL,u32TargetLength, &u32DestLen, uSrc, uSrcLen,&err);
 214         if(err == U_BUFFER_OVERFLOW_ERROR){
 215             err = U_ZERO_ERROR;
 216             u32Target = (UChar32*) malloc (sizeof(uint32_t) * (u32DestLen+1));
 217             u32TargetLength = u32DestLen+1;
 218
 219             u_strToUTF32(u32Target,u32TargetLength, &u32DestLen, uSrc, uSrcLen,&err);
 220         }
 221         else {
 222             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
 223         }
 224         failed = FALSE;
 225
 226         for(i=0; i< u32SrcLen; i++){
 227             if(u32Target[i] != src32[i]){
 228                 log_verbose("u_strToUTF32() failed expected: \\U%08X got: \\U%08X \n", src32[i], u32Target[i]);
 229                 failed =TRUE;
 230             }
 231         }
 232         if(failed){
 233             log_err("u_strToUTF32() failed \n");
 234         }
 235
 236         /* preflight */
 237         u_strFromUTF32(NULL,uTargetLength,&uDestLen,u32Src,u32SrcLen,&err);
 238         if(err == U_BUFFER_OVERFLOW_ERROR){
 239             err = U_ZERO_ERROR;
 240             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
 241             uTargetLength =  uDestLen+1;
 242             u_strFromUTF32(uTarget,uTargetLength,&uDestLen,u32Src,u32SrcLen,&err);
 243
 244         }
 245
 246         for(i=0; i< uDestLen; i++){
 247             if(uTarget[i] != src16[i]){
 248                 log_verbose("u_strFromUTF32() failed expected: \\U%08X got: \\U%08X \n", src16[i] ,uTarget[i]);
 249                 failed =TRUE;
 250             }
 251         }
 252         if(failed){
 253             log_err("u_strToUTF32() failed \n");
 254         }
 255
 256         free(u32Target);
 257         free(uTarget);
 258     }
 259 }
 260
 261
 262 static void Test_UChar_UTF8_API(void){
 263
 264     UErrorCode err = U_ZERO_ERROR;
 265     UChar uTemp[1];
 266     char u8Temp[1];
 267     UChar* uTarget=uTemp;
 268     const char* u8Src;
 269     int32_t u8SrcLen = 0;
 270     int32_t uTargetLength = 0;
 271     int32_t uDestLen=0;
 272     const UChar* uSrc = src16;
 273     int32_t uSrcLen   = sizeof(src16)/2;
 274     char* u8Target = u8Temp;
 275     int32_t u8TargetLength =0;
 276     int32_t u8DestLen =0;
 277     UBool failed = FALSE;
 278     int i= 0;
 279     int32_t numSubstitutions;
 280
 281     {
 282         /* preflight */
 283         u8Temp[0] = 0x12;
 284         u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
 285         if(err == U_BUFFER_OVERFLOW_ERROR && u8Temp[0] == 0x12){
 286             err = U_ZERO_ERROR;
 287             u8Target = (char*) malloc (sizeof(uint8_t) * (u8DestLen+1));
 288             u8TargetLength = u8DestLen;
 289
 290             u8Target[u8TargetLength] = (char)0xfe;
 291             u8DestLen = -1;
 292             u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
 293             if(U_FAILURE(err) || u8DestLen != u8TargetLength || u8Target[u8TargetLength] != (char)0xfe){
 294                 log_err("u_strToUTF8 failed after preflight. Error: %s\n", u_errorName(err));
 295                 return;
 296             }
 297
 298         }
 299         else {
 300             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
 301         }
 302         failed = FALSE;
 303         /*for(i=0; i< u8DestLen; i++){
 304             printf("0x%04X, ",u8Target[i]);
 305             if(i%10==0){
 306                 printf("\n");
 307             }
 308         }*/
 309         /*for(i=0; i< u8DestLen; i++){
 310             if(u8Target[i] != src8[i]){
 311                 log_verbose("u_strToUTF8() failed expected: \\U%08X got: \\U%08X \n", src8[i], u8Target[i]);
 312                 failed =TRUE;
 313             }
 314         }
 315         if(failed){
 316             log_err("u_strToUTF8() failed \n");
 317         }*/
 318         u8Src = u8Target;
 319         u8SrcLen = u8DestLen;
 320
 321         /* preflight */
 322         uTemp[0] = 0x1234;
 323         u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
 324         if(err == U_BUFFER_OVERFLOW_ERROR && uTemp[0] == 0x1234){
 325             err = U_ZERO_ERROR;
 326             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
 327             uTargetLength =  uDestLen;
 328
 329             uTarget[uTargetLength] = 0xfff0;
 330             uDestLen = -1;
 331             u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
 332         }
 333         else {
 334             log_err("error: u_strFromUTF8(preflight) should have gotten U_BUFFER_OVERFLOW_ERROR\n");
 335         }
 336         /*for(i=0; i< uDestLen; i++){
 337             printf("0x%04X, ",uTarget[i]);
 338             if(i%10==0){
 339                 printf("\n");
 340             }
 341         }*/
 342
 343         if(U_FAILURE(err) || uDestLen != uTargetLength || uTarget[uTargetLength] != 0xfff0) {
 344             failed = TRUE;
 345         }
 346         for(i=0; i< uSrcLen; i++){
 347             if(uTarget[i] != src16[i]){
 348                 log_verbose("u_strFromUTF8() failed expected: \\u%04X got: \\u%04X at index: %i \n", src16[i] ,uTarget[i],i);
 349                 failed =TRUE;
 350             }
 351         }
 352         if(failed){
 353             log_err("error: u_strFromUTF8(after preflighting) failed\n");
 354         }
 355
 356         free(u8Target);
 357         free(uTarget);
 358     }
 359     {
 360         u8SrcLen = -1;
 361         uTargetLength = 0;
 362         uSrcLen =-1;
 363         u8TargetLength=0;
 364         failed = FALSE;
 365         /* preflight */
 366         u_strToUTF8(NULL,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
 367         if(err == U_BUFFER_OVERFLOW_ERROR){
 368             err = U_ZERO_ERROR;
 369             u8Target = (char*) malloc (sizeof(uint8_t) * (u8DestLen+1));
 370             u8TargetLength = u8DestLen;
 371
 372             u_strToUTF8(u8Target,u8TargetLength, &u8DestLen, uSrc, uSrcLen,&err);
 373
 374         }
 375         else {
 376             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
 377         }
 378         failed = FALSE;
 379         /*for(i=0; i< u8DestLen; i++){
 380             printf("0x%04X, ",u8Target[i]);
 381             if(i%10==0){
 382                 printf("\n");
 383             }
 384         }*/
 385         /*for(i=0; i< u8DestLen; i++){
 386             if(u8Target[i] != src8[i]){
 387                 log_verbose("u_strToUTF8() failed expected: \\U%08X got: \\U%08X \n", src8[i], u8Target[i]);
 388                 failed =TRUE;
 389             }
 390         }
 391         if(failed){
 392             log_err("u_strToUTF8() failed \n");
 393         }*/
 394         u8Src = u8Target;
 395         u8SrcLen = u8DestLen;
 396
 397         /* preflight */
 398         u_strFromUTF8(NULL,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
 399         if(err == U_BUFFER_OVERFLOW_ERROR){
 400             err = U_ZERO_ERROR;
 401             uTarget = (UChar*) malloc( sizeof(UChar) * (uDestLen+1));
 402             uTargetLength =  uDestLen;
 403
 404             u_strFromUTF8(uTarget,uTargetLength,&uDestLen,u8Src,u8SrcLen,&err);
 405         }
 406         else {
 407             log_err("Should have gotten U_BUFFER_OVERFLOW_ERROR");
 408         }
 409         /*for(i=0; i< uDestLen; i++){
 410             printf("0x%04X, ",uTarget[i]);
 411             if(i%10==0){
 412                 printf("\n");
 413             }
 414         }*/
 415
 416         for(i=0; i< uSrcLen; i++){
 417             if(uTarget[i] != src16[i]){
 418                 log_verbose("u_strFromUTF8() failed expected: \\u%04X got: \\u%04X at index: %i \n", src16[i] ,uTarget[i],i);
 419                 failed =TRUE;
 420             }
 421         }
 422         if(failed){
 423             log_err("u_strToUTF8() failed \n");
 424         }
 425
 426         free(u8Target);
 427         free(uTarget);
 428     }
 429
 430     /* test UTF-8 with single surrogates - illegal in Unicode 3.2 */
 431     {
 432         static const UChar
 433             withLead16[]={ 0x1800, 0xd89a, 0x0061 },
 434             withTrail16[]={ 0x1800, 0xdcba, 0x0061, 0 },
 435             withTrail16SubFFFD[]={ 0x1800, 0xfffd, 0x0061, 0 }, /* sub==U+FFFD */
 436             withTrail16Sub50005[]={ 0x1800, 0xd900, 0xdc05, 0x0061, 0 }; /* sub==U+50005 */
 437         static const uint8_t
 438             withLead8[]={ 0xe1, 0xa0, 0x80, 0xed, 0xa2, 0x9a, 0x61 },
 439             withTrail8[]={ 0xe1, 0xa0, 0x80, 0xed, 0xb2, 0xba, 0x61, 0 },
 440             withTrail8Sub1A[]={ 0xe1, 0xa0, 0x80, 0x1a, 0x61, 0 }, /* sub==U+001A */
 441             withTrail8SubFFFD[]={ 0xe1, 0xa0, 0x80, 0xef, 0xbf, 0xbd, 0x61, 0 }; /* sub==U+FFFD */
 442         UChar out16[10];
 443         char out8[10];
 444
 445         if(
 446             (err=U_ZERO_ERROR, u_strToUTF8(out8, LENGTHOF(out8), NULL, withLead16, LENGTHOF(withLead16), &err), err!=U_INVALID_CHAR_FOUND) ||
 447             (err=U_ZERO_ERROR, u_strToUTF8(out8, LENGTHOF(out8), NULL, withTrail16, -1, &err), err!=U_INVALID_CHAR_FOUND) ||
 448             (err=U_ZERO_ERROR, u_strFromUTF8(out16, LENGTHOF(out16), NULL, (const char *)withLead8, LENGTHOF(withLead8), &err), err!=U_INVALID_CHAR_FOUND) ||
 449             (err=U_ZERO_ERROR, u_strFromUTF8(out16, LENGTHOF(out16), NULL, (const char *)withTrail8, -1, &err), err!=U_INVALID_CHAR_FOUND)
 450         ) {
 451             log_err("error: u_strTo/FromUTF8(string with single surrogate) fails to report error\n");
 452         }
 453
 454         /* test error handling with substitution characters */
 455
 456         /* from UTF-8 with length */
 457         err=U_ZERO_ERROR;
 458         numSubstitutions=-1;
 459         out16[0]=0x55aa;
 460         uDestLen=0;
 461         u_strFromUTF8WithSub(out16, LENGTHOF(out16), &uDestLen,
 462                              (const char *)withTrail8, uprv_strlen((const char *)withTrail8),
 463                              0x50005, &numSubstitutions,
 464                              &err);
 465         if(U_FAILURE(err) || uDestLen!=u_strlen(withTrail16Sub50005) ||
 466                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen+1) ||
 467                              numSubstitutions!=1) {
 468             log_err("error: u_strFromUTF8WithSub(length) failed\n");
 469         }
 470
 471         /* from UTF-8 with NUL termination */
 472         err=U_ZERO_ERROR;
 473         numSubstitutions=-1;
 474         out16[0]=0x55aa;
 475         uDestLen=0;
 476         u_strFromUTF8WithSub(out16, LENGTHOF(out16), &uDestLen,
 477                              (const char *)withTrail8, -1,
 478                              0xfffd, &numSubstitutions,
 479                              &err);
 480         if(U_FAILURE(err) || uDestLen!=u_strlen(withTrail16SubFFFD) ||
 481                              0!=u_memcmp(withTrail16SubFFFD, out16, uDestLen+1) ||
 482                              numSubstitutions!=1) {
 483             log_err("error: u_strFromUTF8WithSub(NUL termination) failed\n");
 484         }
 485
 486         /* preflight from UTF-8 with NUL termination */
 487         err=U_ZERO_ERROR;
 488         numSubstitutions=-1;
 489         out16[0]=0x55aa;
 490         uDestLen=0;
 491         u_strFromUTF8WithSub(out16, 1, &uDestLen,
 492                              (const char *)withTrail8, -1,
 493                              0x50005, &numSubstitutions,
 494                              &err);
 495         if(err!=U_BUFFER_OVERFLOW_ERROR || uDestLen!=u_strlen(withTrail16Sub50005) || numSubstitutions!=1) {
 496             log_err("error: u_strFromUTF8WithSub(preflight/NUL termination) failed\n");
 497         }
 498
 499         /* to UTF-8 with length */
 500         err=U_ZERO_ERROR;
 501         numSubstitutions=-1;
 502         out8[0]=(char)0xf5;
 503         u8DestLen=0;
 504         u_strToUTF8WithSub(out8, LENGTHOF(out8), &u8DestLen,
 505                            withTrail16, u_strlen(withTrail16),
 506                            0xfffd, &numSubstitutions,
 507                            &err);
 508         if(U_FAILURE(err) || u8DestLen!=uprv_strlen((const char *)withTrail8SubFFFD) ||
 509                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen+1) ||
 510                              numSubstitutions!=1) {
 511             log_err("error: u_strToUTF8WithSub(length) failed\n");
 512         }
 513
 514         /* to UTF-8 with NUL termination */
 515         err=U_ZERO_ERROR;
 516         numSubstitutions=-1;
 517         out8[0]=(char)0xf5;
 518         u8DestLen=0;
 519         u_strToUTF8WithSub(out8, LENGTHOF(out8), &u8DestLen,
 520                            withTrail16, -1,
 521                            0x1a, &numSubstitutions,
 522                            &err);
 523         if(U_FAILURE(err) || u8DestLen!=uprv_strlen((const char *)withTrail8Sub1A) ||
 524                              0!=uprv_memcmp((const char *)withTrail8Sub1A, out8, u8DestLen+1) ||
 525                              numSubstitutions!=1) {
 526             log_err("error: u_strToUTF8WithSub(NUL termination) failed\n");
 527         }
 528
 529         /* preflight to UTF-8 with NUL termination */
 530         err=U_ZERO_ERROR;
 531         numSubstitutions=-1;
 532         out8[0]=(char)0xf5;
 533         u8DestLen=0;
 534         u_strToUTF8WithSub(out8, 1, &u8DestLen,
 535                            withTrail16, -1,
 536                            0xfffd, &numSubstitutions,
 537                            &err);
 538         if(err!=U_BUFFER_OVERFLOW_ERROR || u8DestLen!=uprv_strlen((const char *)withTrail8SubFFFD) ||
 539                                            numSubstitutions!=1) {
 540             log_err("error: u_strToUTF8WithSub(preflight/NUL termination) failed\n");
 541         }
 542
 543         /* test that numSubstitutions==0 if there are no substitutions */
 544
 545         /* from UTF-8 with length (just first 3 bytes which are valid) */
 546         err=U_ZERO_ERROR;
 547         numSubstitutions=-1;
 548         out16[0]=0x55aa;
 549         uDestLen=0;
 550         u_strFromUTF8WithSub(out16, LENGTHOF(out16), &uDestLen,
 551                              (const char *)withTrail8, 3,
 552                              0x50005, &numSubstitutions,
 553                              &err);
 554         if(U_FAILURE(err) || uDestLen!=1 ||
 555                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen) ||
 556                              numSubstitutions!=0) {
 557             log_err("error: u_strFromUTF8WithSub(no subs) failed\n");
 558         }
 559
 560         /* to UTF-8 with length (just first UChar which is valid) */
 561         err=U_ZERO_ERROR;
 562         numSubstitutions=-1;
 563         out8[0]=(char)0xf5;
 564         u8DestLen=0;
 565         u_strToUTF8WithSub(out8, LENGTHOF(out8), &u8DestLen,
 566                            withTrail16, 1,
 567                            0xfffd, &numSubstitutions,
 568                            &err);
 569         if(U_FAILURE(err) || u8DestLen!=3 ||
 570                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen) ||
 571                              numSubstitutions!=0) {
 572             log_err("error: u_strToUTF8WithSub(no subs) failed\n");
 573         }
 574
 575         /* test that numSubstitutions==0 if subchar==U_SENTINEL (no subchar) */
 576
 577         /* from UTF-8 with length (just first 3 bytes which are valid) */
 578         err=U_ZERO_ERROR;
 579         numSubstitutions=-1;
 580         out16[0]=0x55aa;
 581         uDestLen=0;
 582         u_strFromUTF8WithSub(out16, LENGTHOF(out16), &uDestLen,
 583                              (const char *)withTrail8, 3,
 584                              U_SENTINEL, &numSubstitutions,
 585                              &err);
 586         if(U_FAILURE(err) || uDestLen!=1 ||
 587                              0!=u_memcmp(withTrail16Sub50005, out16, uDestLen) ||
 588                              numSubstitutions!=0) {
 589             log_err("error: u_strFromUTF8WithSub(no subchar) failed\n");
 590         }
 591
 592         /* to UTF-8 with length (just first UChar which is valid) */
 593         err=U_ZERO_ERROR;
 594         numSubstitutions=-1;
 595         out8[0]=(char)0xf5;
 596         u8DestLen=0;
 597         u_strToUTF8WithSub(out8, LENGTHOF(out8), &u8DestLen,
 598                            withTrail16, 1,
 599                            U_SENTINEL, &numSubstitutions,
 600                            &err);
 601         if(U_FAILURE(err) || u8DestLen!=3 ||
 602                              0!=uprv_memcmp((const char *)withTrail8SubFFFD, out8, u8DestLen) ||
 603                              numSubstitutions!=0) {
 604             log_err("error: u_strToUTF8WithSub(no subchar) failed\n");
 605         }
 606     }
 607 }
 608
 609 /* compare if two strings are equal, but match 0xfffd in the second string with anything in the first */
 610 static UBool
 611 equalAnyFFFD(const UChar *s, const UChar *t, int32_t length) {
 612     UChar c1, c2;
 613
 614     while(length>0) {
 615         c1=*s++;
 616         c2=*t++;
 617         if(c1!=c2 && c2!=0xfffd) {
 618             return FALSE;
 619         }
 620         --length;
 621     }
 622     return TRUE;
 623 }
 624
 625 /* test u_strFromUTF8Lenient() */
 626 static void
 627 Test_FromUTF8(void) {
 628     /*
 629      * Test case from icu-support list 20071130 "u_strFromUTF8() returns U_INVALID_CHAR_FOUND(10)"
 630      */
 631     static const uint8_t bytes[]={ 0xe0, 0xa5, 0x9c, 0 };
 632     UChar dest[64];
 633     UChar *destPointer;
 634     int32_t destLength;
 635     UErrorCode errorCode;
 636
 637     /* 3 bytes input, one UChar output (U+095C) */
 638     errorCode=U_ZERO_ERROR;
 639     destLength=-99;
 640     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, 3, &errorCode);
 641     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=1) {
 642         log_err("error: u_strFromUTF8(preflight srcLength=3) fails: destLength=%ld - %s\n",
 643                 (long)destLength, u_errorName(errorCode));
 644     }
 645
 646     /* 4 bytes input, two UChars output (U+095C U+0000) */
 647     errorCode=U_ZERO_ERROR;
 648     destLength=-99;
 649     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, 4, &errorCode);
 650     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=2) {
 651         log_err("error: u_strFromUTF8(preflight srcLength=4) fails: destLength=%ld - %s\n",
 652                 (long)destLength, u_errorName(errorCode));
 653     }
 654
 655     /* NUL-terminated 3 bytes input, one UChar output (U+095C) */
 656     errorCode=U_ZERO_ERROR;
 657     destLength=-99;
 658     destPointer=u_strFromUTF8(NULL, 0, &destLength, (const char *)bytes, -1, &errorCode);
 659     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || destPointer!=NULL || destLength!=1) {
 660         log_err("error: u_strFromUTF8(preflight srcLength=-1) fails: destLength=%ld - %s\n",
 661                 (long)destLength, u_errorName(errorCode));
 662     }
 663
 664     /* 3 bytes input, one UChar output (U+095C), transform not just preflight */
 665     errorCode=U_ZERO_ERROR;
 666     dest[0]=dest[1]=99;
 667     destLength=-99;
 668     destPointer=u_strFromUTF8(dest, LENGTHOF(dest), &destLength, (const char *)bytes, 3, &errorCode);
 669     if(U_FAILURE(errorCode) || destPointer!=dest || destLength!=1 || dest[0]!=0x95c || dest[1]!=0) {
 670         log_err("error: u_strFromUTF8(transform srcLength=3) fails: destLength=%ld - %s\n",
 671                 (long)destLength, u_errorName(errorCode));
 672     }
 673 }
 674
 675 /* test u_strFromUTF8Lenient() */
 676 static void
 677 Test_FromUTF8Lenient(void) {
 678     /*
 679      * Multiple input strings, each NUL-terminated.
 680      * Terminate with a string starting with 0xff.
 681      */
 682     static const uint8_t bytes[]={
 683         /* well-formed UTF-8 */
 684         0x61,  0xc3, 0x9f,  0xe0, 0xa0, 0x80,  0xf0, 0xa0, 0x80, 0x80,
 685         0x62,  0xc3, 0xa0,  0xe0, 0xa0, 0x81,  0xf0, 0xa0, 0x80, 0x81, 0,
 686
 687         /* various malformed sequences */
 688         0xc3, 0xc3, 0x9f,  0xc3, 0xa0,  0xe0, 0x80, 0x8a,  0xf0, 0x41, 0x42, 0x43, 0,
 689
 690         /* truncated input */
 691         0xc3, 0,
 692         0xe0, 0,
 693         0xe0, 0xa0, 0,
 694         0xf0, 0,
 695         0xf0, 0x90, 0,
 696         0xf0, 0x90, 0x80, 0,
 697
 698         /* non-ASCII characters in the last few bytes */
 699         0x61,  0xc3, 0x9f,  0xe0, 0xa0, 0x80, 0,
 700         0x61,  0xe0, 0xa0, 0x80,  0xc3, 0x9f, 0,
 701
 702         /* empty string */
 703         0,
 704
 705         /* finish */
 706         0xff, 0
 707     };
 708
 709     /* Multiple output strings, each NUL-terminated. 0xfffd matches anything. */
 710     static const UChar uchars[]={
 711         0x61, 0xdf, 0x800,  0xd840, 0xdc00,
 712         0x62, 0xe0, 0x801,  0xd840, 0xdc01,  0,
 713
 714         0xfffd, 0x9f, 0xe0, 0xa,  0xfffd, 0xfffd,  0,
 715
 716         0xfffd, 0,
 717         0xfffd, 0,
 718         0xfffd, 0,
 719         0xfffd, 0,
 720         0xfffd, 0,
 721         0xfffd, 0,
 722
 723         0x61, 0xdf, 0x800,  0,
 724         0x61, 0x800, 0xdf,  0,
 725
 726         0,
 727
 728         0
 729     };
 730
 731     UChar dest[64];
 732     const char *pb;
 733     const UChar *pu, *pDest;
 734     int32_t srcLength, destLength0, destLength;
 735     int number;
 736     UErrorCode errorCode;
 737
 738     /* verify checking for some illegal arguments */
 739     dest[0]=0x1234;
 740     destLength=-1;
 741     errorCode=U_ZERO_ERROR;
 742     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, NULL, -1, &errorCode);
 743     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || dest[0]!=0x1234) {
 744         log_err("u_strFromUTF8Lenient(src=NULL) failed\n");
 745     }
 746
 747     dest[0]=0x1234;
 748     destLength=-1;
 749     errorCode=U_ZERO_ERROR;
 750     pDest=u_strFromUTF8Lenient(NULL, 1, &destLength, (const char *)bytes, -1, &errorCode);
 751     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
 752         log_err("u_strFromUTF8Lenient(dest=NULL[1]) failed\n");
 753     }
 754
 755     dest[0]=0x1234;
 756     destLength=-1;
 757     errorCode=U_MEMORY_ALLOCATION_ERROR;
 758     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, (const char *)bytes, -1, &errorCode);
 759     if(errorCode!=U_MEMORY_ALLOCATION_ERROR || dest[0]!=0x1234) {
 760         log_err("u_strFromUTF8Lenient(U_MEMORY_ALLOCATION_ERROR) failed\n");
 761     }
 762
 763     dest[0]=0x1234;
 764     destLength=-1;
 765     errorCode=U_MEMORY_ALLOCATION_ERROR;
 766     pDest=u_strFromUTF8Lenient(dest, 1, &destLength, (const char *)bytes, -1, NULL);
 767     if(dest[0]!=0x1234) {
 768         log_err("u_strFromUTF8Lenient(pErrorCode=NULL) failed\n");
 769     }
 770
 771     /* test normal behavior */
 772     number=0; /* string number for log_err() */
 773
 774     for(pb=(const char *)bytes, pu=uchars;
 775         *pb!=(char)0xff;
 776         pb+=srcLength+1, pu+=destLength0+1, ++number
 777     ) {
 778         srcLength=uprv_strlen(pb);
 779         destLength0=u_strlen(pu);
 780
 781         /* preflighting with NUL-termination */
 782         dest[0]=0x1234;
 783         destLength=-1;
 784         errorCode=U_ZERO_ERROR;
 785         pDest=u_strFromUTF8Lenient(NULL, 0, &destLength, pb, -1, &errorCode);
 786         if (errorCode!= (destLength0==0 ? U_STRING_NOT_TERMINATED_WARNING : U_BUFFER_OVERFLOW_ERROR) ||
 787             pDest!=NULL || dest[0]!=0x1234 || destLength!=destLength0
 788         ) {
 789             log_err("u_strFromUTF8Lenient(%d preflighting with NUL-termination) failed\n", number);
 790         }
 791
 792         /* preflighting/some capacity with NUL-termination */
 793         if(srcLength>0) {
 794             dest[destLength0-1]=0x1234;
 795             destLength=-1;
 796             errorCode=U_ZERO_ERROR;
 797             pDest=u_strFromUTF8Lenient(dest, destLength0-1, &destLength, pb, -1, &errorCode);
 798             if (errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 799                 dest[destLength0-1]!=0x1234 || destLength!=destLength0
 800             ) {
 801                 log_err("u_strFromUTF8Lenient(%d preflighting/some capacity with NUL-termination) failed\n", number);
 802             }
 803         }
 804
 805         /* conversion with NUL-termination, much capacity */
 806         dest[0]=dest[destLength0]=0x1234;
 807         destLength=-1;
 808         errorCode=U_ZERO_ERROR;
 809         pDest=u_strFromUTF8Lenient(dest, LENGTHOF(dest), &destLength, pb, -1, &errorCode);
 810         if (errorCode!=U_ZERO_ERROR ||
 811             pDest!=dest || dest[destLength0]!=0 ||
 812             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
 813         ) {
 814             log_err("u_strFromUTF8Lenient(%d conversion with NUL-termination, much capacity) failed\n", number);
 815         }
 816
 817         /* conversion with NUL-termination, exact capacity */
 818         dest[0]=dest[destLength0]=0x1234;
 819         destLength=-1;
 820         errorCode=U_ZERO_ERROR;
 821         pDest=u_strFromUTF8Lenient(dest, destLength0, &destLength, pb, -1, &errorCode);
 822         if (errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
 823             pDest!=dest || dest[destLength0]!=0x1234 ||
 824             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
 825         ) {
 826             log_err("u_strFromUTF8Lenient(%d conversion with NUL-termination, exact capacity) failed\n", number);
 827         }
 828
 829         /* preflighting with length */
 830         dest[0]=0x1234;
 831         destLength=-1;
 832         errorCode=U_ZERO_ERROR;
 833         pDest=u_strFromUTF8Lenient(NULL, 0, &destLength, pb, srcLength, &errorCode);
 834         if (errorCode!= (destLength0==0 ? U_STRING_NOT_TERMINATED_WARNING : U_BUFFER_OVERFLOW_ERROR) ||
 835             pDest!=NULL || dest[0]!=0x1234 || destLength!=srcLength
 836         ) {
 837             log_err("u_strFromUTF8Lenient(%d preflighting with length) failed\n", number);
 838         }
 839
 840         /* preflighting/some capacity with length */
 841         if(srcLength>0) {
 842             dest[srcLength-1]=0x1234;
 843             destLength=-1;
 844             errorCode=U_ZERO_ERROR;
 845             pDest=u_strFromUTF8Lenient(dest, srcLength-1, &destLength, pb, srcLength, &errorCode);
 846             if (errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 847                 dest[srcLength-1]!=0x1234 || destLength!=srcLength
 848             ) {
 849                 log_err("u_strFromUTF8Lenient(%d preflighting/some capacity with length) failed\n", number);
 850             }
 851         }
 852
 853         /* conversion with length, much capacity */
 854         dest[0]=dest[destLength0]=0x1234;
 855         destLength=-1;
 856         errorCode=U_ZERO_ERROR;
 857         pDest=u_strFromUTF8Lenient(dest, LENGTHOF(dest), &destLength, pb, srcLength, &errorCode);
 858         if (errorCode!=U_ZERO_ERROR ||
 859             pDest!=dest || dest[destLength0]!=0 ||
 860             destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
 861         ) {
 862             log_err("u_strFromUTF8Lenient(%d conversion with length, much capacity) failed\n", number);
 863         }
 864
 865         /* conversion with length, srcLength capacity */
 866         dest[0]=dest[srcLength]=dest[destLength0]=0x1234;
 867         destLength=-1;
 868         errorCode=U_ZERO_ERROR;
 869         pDest=u_strFromUTF8Lenient(dest, srcLength, &destLength, pb, srcLength, &errorCode);
 870         if(srcLength==destLength0) {
 871             if (errorCode!=U_STRING_NOT_TERMINATED_WARNING ||
 872                 pDest!=dest || dest[destLength0]!=0x1234 ||
 873                 destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
 874             ) {
 875                 log_err("u_strFromUTF8Lenient(%d conversion with length, srcLength capacity/not terminated) failed\n", number);
 876             }
 877         } else {
 878             if (errorCode!=U_ZERO_ERROR ||
 879                 pDest!=dest || dest[destLength0]!=0 ||
 880                 destLength!=destLength0 || !equalAnyFFFD(dest, pu, destLength)
 881             ) {
 882                 log_err("u_strFromUTF8Lenient(%d conversion with length, srcLength capacity/terminated) failed\n", number);
 883             }
 884         }
 885     }
 886 }
 887
 888 static const uint16_t src16j[] = {
 889     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
 890     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
 891     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
 892     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
 893     0x0000,
 894     /* Test only ASCII */
 895
 896 };
 897 static const uint16_t src16WithNulls[] = {
 898     0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0000,
 899     0x0048, 0x0049, 0x004A, 0x000D, 0x000A, 0x0000,
 900     0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0000,
 901     0x0050, 0x0051, 0x0052, 0x000D, 0x000A, 0x0000,
 902     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0000,
 903     0x0058, 0x0059, 0x005A, 0x000D, 0x000A, 0x0000,
 904     0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0000,
 905     0x0058, 0x0059, 0x005A, 0x000D, 0x000A, 0x0000,
 906     /* test only ASCII */
 907     /*
 908     0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD,
 909     0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
 910     0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1,
 911     0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB,
 912     0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5,
 913     0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
 914     0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
 915     0x0054, 0x0000 */
 916
 917 };
 918 static void Test_UChar_WCHART_API(void){
 919 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
 920     UErrorCode err = U_ZERO_ERROR;
 921     const UChar* uSrc = src16j;
 922     int32_t uSrcLen = sizeof(src16j)/2;
 923     wchar_t* wDest = NULL;
 924     int32_t wDestLen = 0;
 925     int32_t reqLen= 0 ;
 926     UBool failed = FALSE;
 927     UChar* uDest = NULL;
 928     int32_t uDestLen = 0;
 929     int i =0;
 930     {
 931         /* Bad UErrorCode arguments. Make sure that the API doesn't crash, and that Purify doesn't complain. */
 932         if (u_strFromWCS(NULL,0,NULL,NULL,0,NULL) != NULL) {
 933             log_err("u_strFromWCS() should return NULL with a bad argument\n");
 934         }
 935         if (u_strToWCS(NULL,0,NULL,NULL,0,NULL) != NULL) {
 936             log_err("u_strToWCS() should return NULL with a bad argument\n");
 937         }
 938
 939         /* Bad UErrorCode arguments. */
 940         err = U_ZERO_ERROR;
 941         u_strFromWCS(NULL,0,NULL,NULL,0,&err);
 942         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
 943             log_err("u_strFromWCS() didn't fail as expected with bad arguments. Error: %s \n", u_errorName(err));
 944         }
 945         err = U_ZERO_ERROR;
 946         u_strToWCS(NULL,0,NULL,NULL,0,&err);
 947         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
 948             log_err("u_strToWCS() didn't fail as expected with bad arguments. Error: %s \n", u_errorName(err));
 949         }
 950         err = U_ZERO_ERROR;
 951
 952         /* pre-flight*/
 953         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
 954
 955         if(err == U_BUFFER_OVERFLOW_ERROR){
 956             err=U_ZERO_ERROR;
 957             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
 958             wDestLen = reqLen+1;
 959             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
 960         }
 961
 962         /* pre-flight */
 963         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
 964
 965
 966         if(err == U_BUFFER_OVERFLOW_ERROR){
 967             err =U_ZERO_ERROR;
 968             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
 969             uDestLen = reqLen + 1;
 970             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
 971         }else if(U_FAILURE(err)){
 972
 973             log_err("u_strFromWCS() failed. Error: %s \n", u_errorName(err));
 974             return;
 975         }
 976
 977         for(i=0; i< uSrcLen; i++){
 978             if(uDest[i] != src16j[i]){
 979                 log_verbose("u_str*WCS() failed for unterminated string expected: \\u%04X got: \\u%04X at index: %i \n", src16j[i] ,uDest[i],i);
 980                 failed =TRUE;
 981             }
 982         }
 983
 984         if(U_FAILURE(err)){
 985             failed = TRUE;
 986         }
 987         if(failed){
 988             log_err("u_strToWCS() failed \n");
 989         }
 990         free(wDest);
 991         free(uDest);
 992
 993
 994         /* test with embeded nulls */
 995         uSrc = src16WithNulls;
 996         uSrcLen = sizeof(src16WithNulls)/2;
 997         wDestLen =0;
 998         uDestLen =0;
 999         wDest = NULL;
1000         uDest = NULL;
1001         /* pre-flight*/
1002         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
1003
1004         if(err == U_BUFFER_OVERFLOW_ERROR){
1005             err=U_ZERO_ERROR;
1006             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
1007             wDestLen = reqLen+1;
1008             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
1009         }
1010
1011         /* pre-flight */
1012         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
1013
1014         if(err == U_BUFFER_OVERFLOW_ERROR){
1015             err =U_ZERO_ERROR;
1016             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
1017             uDestLen = reqLen + 1;
1018             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,reqLen,&err);
1019         }
1020
1021
1022         for(i=0; i< uSrcLen; i++){
1023             if(uDest[i] != src16WithNulls[i]){
1024                 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);
1025                 failed =TRUE;
1026             }
1027         }
1028
1029         if(U_FAILURE(err)){
1030             failed = TRUE;
1031         }
1032         if(failed){
1033             log_err("u_strToWCS() failed \n");
1034         }
1035         free(wDest);
1036         free(uDest);
1037
1038     }
1039
1040     {
1041
1042         uSrc = src16j;
1043         uSrcLen = sizeof(src16j)/2;
1044         wDestLen =0;
1045         uDestLen =0;
1046         wDest = NULL;
1047         uDest = NULL;
1048         wDestLen = 0;
1049         /* pre-flight*/
1050         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&err);
1051
1052         if(err == U_BUFFER_OVERFLOW_ERROR){
1053             err=U_ZERO_ERROR;
1054             wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
1055             wDestLen = reqLen+1;
1056             u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&err);
1057         }
1058         uDestLen = 0;
1059         /* pre-flight */
1060         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&err);
1061
1062         if(err == U_BUFFER_OVERFLOW_ERROR){
1063             err =U_ZERO_ERROR;
1064             uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
1065             uDestLen = reqLen + 1;
1066             u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&err);
1067         }
1068
1069
1070         for(i=0; i< uSrcLen; i++){
1071             if(uDest[i] != src16j[i]){
1072                 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);
1073                 failed =TRUE;
1074             }
1075         }
1076
1077         if(U_FAILURE(err)){
1078             failed = TRUE;
1079         }
1080         if(failed){
1081             log_err("u_strToWCS() failed \n");
1082         }
1083         free(wDest);
1084         free(uDest);
1085     }
1086
1087     /*
1088      * Test u_terminateWChars().
1089      * All u_terminateXYZ() use the same implementation macro;
1090      * we test this function to improve API coverage.
1091      */
1092     {
1093         wchar_t buffer[10];
1094
1095         err=U_ZERO_ERROR;
1096         buffer[3]=0x20ac;
1097         wDestLen=u_terminateWChars(buffer, LENGTHOF(buffer), 3, &err);
1098         if(err!=U_ZERO_ERROR || wDestLen!=3 || buffer[3]!=0) {
1099             log_err("u_terminateWChars(buffer, all, 3, zero) failed: %s length %d [3]==U+%04x\n",
1100                     u_errorName(err), wDestLen, buffer[3]);
1101         }
1102
1103         err=U_ZERO_ERROR;
1104         buffer[3]=0x20ac;
1105         wDestLen=u_terminateWChars(buffer, 3, 3, &err);
1106         if(err!=U_STRING_NOT_TERMINATED_WARNING || wDestLen!=3 || buffer[3]!=0x20ac) {
1107             log_err("u_terminateWChars(buffer, 3, 3, zero) failed: %s length %d [3]==U+%04x\n",
1108                     u_errorName(err), wDestLen, buffer[3]);
1109         }
1110
1111         err=U_STRING_NOT_TERMINATED_WARNING;
1112         buffer[3]=0x20ac;
1113         wDestLen=u_terminateWChars(buffer, LENGTHOF(buffer), 3, &err);
1114         if(err!=U_ZERO_ERROR || wDestLen!=3 || buffer[3]!=0) {
1115             log_err("u_terminateWChars(buffer, all, 3, not-terminated) failed: %s length %d [3]==U+%04x\n",
1116                     u_errorName(err), wDestLen, buffer[3]);
1117         }
1118
1119         err=U_ZERO_ERROR;
1120         buffer[3]=0x20ac;
1121         wDestLen=u_terminateWChars(buffer, 2, 3, &err);
1122         if(err!=U_BUFFER_OVERFLOW_ERROR || wDestLen!=3 || buffer[3]!=0x20ac) {
1123             log_err("u_terminateWChars(buffer, 2, 3, zero) failed: %s length %d [3]==U+%04x\n",
1124                     u_errorName(err), wDestLen, buffer[3]);
1125         }
1126     }
1127 #else
1128     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
1129 #endif
1130 }
1131
1132 static void Test_widestrs()
1133 {
1134 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
1135         wchar_t ws[100];
1136         UChar rts[100];
1137         int32_t wcap = sizeof(ws) / sizeof(*ws);
1138         int32_t wl;
1139         int32_t rtcap = sizeof(rts) / sizeof(*rts);
1140         int32_t rtl;
1141         wchar_t *wcs;
1142         UChar *cp;
1143         const char *errname;
1144         UChar ustr[] = {'h', 'e', 'l', 'l', 'o', 0};
1145         int32_t ul = sizeof(ustr)/sizeof(*ustr) -1;
1146         char astr[100];
1147
1148         UErrorCode err;
1149
1150         err = U_ZERO_ERROR;
1151         wcs = u_strToWCS(ws, wcap, &wl, ustr, ul, &err);
1152         if (U_FAILURE(err)) {
1153                 errname = u_errorName(err);
1154                 log_err("test_widestrs: u_strToWCS error: %s!\n",errname);
1155         }
1156         if(ul!=wl){
1157             log_err("u_strToWCS: ustr = %s, ul = %d, ws = %S, wl = %d!\n", u_austrcpy(astr, ustr), ul, ws, wl);
1158         }
1159         err = U_ZERO_ERROR;
1160         wl = (int32_t)uprv_wcslen(wcs);
1161         cp = u_strFromWCS(rts, rtcap, &rtl, wcs, wl, &err);
1162         if (U_FAILURE(err)) {
1163                 errname = u_errorName(err);
1164                 fprintf(stderr, "test_widestrs: ucnv_wcstombs error: %s!\n",errname);
1165         }
1166         if(wl != rtl){
1167             log_err("u_strFromWCS: wcs = %S, wl = %d,rts = %s, rtl = %d!\n", wcs, wl, u_austrcpy(astr, rts), rtl);
1168         }
1169 #else
1170     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
1171 #endif
1172 }
1173
1174 static void
1175 Test_WCHART_LongString(){
1176 #if (defined(U_WCHAR_IS_UTF16) || defined(U_WCHAR_IS_UTF32)) || (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION)
1177     UErrorCode status = U_ZERO_ERROR;
1178     const char* testdatapath=loadTestData(&status);
1179     UResourceBundle *theBundle = ures_open(testdatapath, "testtypes", &status);
1180     int32_t strLen =0;
1181     const UChar* str = ures_getStringByKey(theBundle, "testinclude",&strLen,&status);
1182     const UChar* uSrc = str;
1183     int32_t uSrcLen = strLen;
1184     int32_t wDestLen =0, reqLen=0, i=0;
1185     int32_t uDestLen =0;
1186     wchar_t* wDest = NULL;
1187     UChar* uDest = NULL;
1188     UBool failed = FALSE;
1189
1190     if(U_FAILURE(status)){
1191         log_data_err("Could not get testinclude resource from testtypes bundle. Error: %s\n",u_errorName(status));
1192         return;
1193     }
1194
1195     /* pre-flight*/
1196     u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&status);
1197
1198     if(status == U_BUFFER_OVERFLOW_ERROR){
1199         status=U_ZERO_ERROR;
1200         wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
1201         wDestLen = reqLen+1;
1202         u_strToWCS(wDest,wDestLen,&reqLen,uSrc,-1,&status);
1203     }
1204     uDestLen = 0;
1205     /* pre-flight */
1206     u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&status);
1207
1208     if(status == U_BUFFER_OVERFLOW_ERROR){
1209         status =U_ZERO_ERROR;
1210         uDest = (UChar*) malloc(sizeof(UChar) * (reqLen+1));
1211         uDestLen = reqLen + 1;
1212         u_strFromWCS(uDest, uDestLen,&reqLen,wDest,-1,&status);
1213     }
1214
1215
1216     for(i=0; i< uSrcLen; i++){
1217         if(uDest[i] != str[i]){
1218             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);
1219             failed =TRUE;
1220         }
1221     }
1222
1223     if(U_FAILURE(status)){
1224         failed = TRUE;
1225     }
1226     if(failed){
1227         log_err("u_strToWCS() failed \n");
1228     }
1229     free(wDest);
1230     free(uDest);
1231     /* close the bundle */
1232     ures_close(theBundle);
1233 #else
1234     log_info("Not testing u_str*WCS because (!UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION) and wchar is neither utf16 nor utf32");
1235 #endif
1236 }
1237