icuSources/test/cintltst/cstrtest.c

   1 /*
   2 **********************************************************************
   3 * Copyright (C) 1998-2010, International Business Machines Corporation
   4 * and others.  All Rights Reserved.
   5 **********************************************************************
   6 *
   7 * File cstrtest.c
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   07/13/2000  Madhu         created
  13 *******************************************************************************
  14 */
  15
  16 #include "unicode/ustring.h"
  17 #include "unicode/ucnv.h"
  18 #include "cstring.h"
  19 #include "uinvchar.h"
  20 #include "cintltst.h"
  21 #include "cmemory.h"
  22
  23 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  24
  25 static void TestAPI(void);
  26 void addCStringTest(TestNode** root);
  27
  28 static void TestInvariant(void);
  29 static void TestCompareInvEbcdicAsAscii(void);
  30
  31 void addCStringTest(TestNode** root) {
  32     addTest(root, &TestAPI,   "tsutil/cstrtest/TestAPI");
  33     addTest(root, &TestInvariant,   "tsutil/cstrtest/TestInvariant");
  34     addTest(root, &TestCompareInvEbcdicAsAscii, "tsutil/cstrtest/TestCompareInvEbcdicAsAscii");
  35 }
  36
  37 static void TestAPI(void)
  38 {
  39     int32_t intValue=0;
  40     char src[30]="HELLO THERE", dest[30];
  41     static const char *const abc="abcdefghijklmnopqrstuvwxyz", *const ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  42     const char *temp;
  43     int32_t i;
  44
  45     log_verbose("Testing uprv_tolower() and uprv_toupper()\n");
  46     for(i=0; i<=26; ++i) {
  47         dest[i]=uprv_tolower(abc[i]);
  48     }
  49     if(0!=strcmp(abc, dest)) {
  50         log_err("uprv_tolower(abc) failed\n");
  51     }
  52
  53     for(i=0; i<=26; ++i) {
  54         dest[i]=uprv_tolower(ABC[i]);
  55     }
  56     if(0!=strcmp(abc, dest)) {
  57         log_err("uprv_tolower(ABC) failed\n");
  58     }
  59
  60     for(i=0; i<=26; ++i) {
  61         dest[i]=uprv_toupper(abc[i]);
  62     }
  63     if(0!=strcmp(ABC, dest)) {
  64         log_err("uprv_toupper(abc) failed\n");
  65     }
  66
  67     for(i=0; i<=26; ++i) {
  68         dest[i]=uprv_toupper(ABC[i]);
  69     }
  70     if(0!=strcmp(ABC, dest)) {
  71         log_err("uprv_toupper(ABC) failed\n");
  72     }
  73
  74     log_verbose("Testing the API in cstring\n");
  75     T_CString_toLowerCase(src);
  76     if(uprv_strcmp(src, "hello there") != 0){
  77         log_err("FAIL: *** T_CString_toLowerCase() failed. Expected: \"hello there\", Got: \"%s\"\n", src);
  78     }
  79     T_CString_toUpperCase(src);
  80     if(uprv_strcmp(src, "HELLO THERE") != 0){
  81         log_err("FAIL: *** T_CString_toUpperCase() failed. Expected: \"HELLO THERE\", Got: \"%s\"\n", src);
  82     }
  83
  84     intValue=T_CString_stringToInteger("34556", 10);
  85     if(intValue != 34556){
  86         log_err("FAIL: ****T_CString_stringToInteger(\"34556\", 10) failed. Expected: 34556, Got: %d\n", intValue);
  87     }
  88     intValue=T_CString_stringToInteger("100", 16);
  89     if(intValue != 256){
  90         log_err("FAIL: ****T_CString_stringToInteger(\"100\", 16) failed. Expected: 256, Got: %d\n", intValue);
  91     }
  92     i = T_CString_integerToString(src, 34556, 10);
  93     if(uprv_strcmp(src, "34556") != 0 || i != 5){
  94         log_err("FAIL: ****integerToString(src, 34566, 10); failed. Expected: \"34556\", Got: %s\n", src);
  95     }
  96     i = T_CString_integerToString(src, 431, 16);
  97     if(uprv_stricmp(src, "1AF") != 0 || i != 3){
  98         log_err("FAIL: ****integerToString(src, 431, 16); failed. Expected: \"1AF\", Got: %s\n", src);
  99     }
 100     i = T_CString_int64ToString(src, U_INT64_MAX, 10);
 101     if(uprv_strcmp(src,  "9223372036854775807") != 0 || i != 19){
 102         log_err("FAIL: ****integerToString(src, 9223372036854775807, 10); failed. Got: %s\n", src);
 103     }
 104     i = T_CString_int64ToString(src, U_INT64_MAX, 16);
 105     if(uprv_stricmp(src, "7FFFFFFFFFFFFFFF") != 0 || i != 16){
 106         log_err("FAIL: ****integerToString(src, 7FFFFFFFFFFFFFFF, 16); failed. Got: %s\n", src);
 107     }
 108
 109     uprv_strcpy(src, "this is lower case");
 110     if(T_CString_stricmp(src, "THIS is lower CASE") != 0){
 111         log_err("FAIL: *****T_CString_stricmp() failed.");
 112     }
 113     if((intValue=T_CString_stricmp(NULL, "first string is null") )!= -1){
 114         log_err("FAIL: T_CString_stricmp() where the first string is null failed. Expected: -1, returned %d\n", intValue);
 115     }
 116     if((intValue=T_CString_stricmp("second string is null", NULL)) != 1){
 117         log_err("FAIL: T_CString_stricmp() where the second string is null failed. Expected: 1, returned %d\n", intValue);
 118     }
 119     if((intValue=T_CString_stricmp(NULL, NULL)) != 0){
 120         log_err("FAIL: T_CString_stricmp(NULL, NULL) failed.  Expected:  0, returned %d\n", intValue);;
 121     }
 122     if((intValue=T_CString_stricmp("", "")) != 0){
 123         log_err("FAIL: T_CString_stricmp(\"\", \"\") failed.  Expected:  0, returned %d\n", intValue);;
 124     }
 125     if((intValue=T_CString_stricmp("", "abc")) != -1){
 126         log_err("FAIL: T_CString_stricmp(\"\", \"abc\") failed.  Expected: -1, returned %d\n", intValue);
 127     }
 128     if((intValue=T_CString_stricmp("abc", "")) != 1){
 129         log_err("FAIL: T_CString_stricmp(\"abc\", \"\") failed.  Expected: 1, returned %d\n", intValue);
 130     }
 131
 132     temp=uprv_strdup("strdup");
 133     if(uprv_strcmp(temp, "strdup") !=0 ){
 134         log_err("FAIL: uprv_strdup() failed. Expected: \"strdup\", Got: %s\n", temp);
 135     }
 136     uprv_free((char *)temp);
 137
 138     uprv_strcpy(src, "this is lower case");
 139     if(T_CString_strnicmp(src, "THIS", 4 ) != 0){
 140         log_err("FAIL: *****T_CString_strnicmp() failed.");
 141     }
 142     if((intValue=T_CString_strnicmp(NULL, "first string is null", 10) )!= -1){
 143         log_err("FAIL: T_CString_strnicmp() where the first string is null failed. Expected: -1, returned %d\n", intValue);
 144     }
 145     if((intValue=T_CString_strnicmp("second string is null", NULL, 10)) != 1){
 146         log_err("FAIL: T_CString_strnicmp() where the second string is null failed. Expected: 1, returned %d\n", intValue);
 147     }
 148     if((intValue=T_CString_strnicmp(NULL, NULL, 10)) != 0){
 149         log_err("FAIL: T_CString_strnicmp(NULL, NULL, 10) failed.  Expected:  0, returned %d\n", intValue);;
 150     }
 151     if((intValue=T_CString_strnicmp("", "", 10)) != 0){
 152         log_err("FAIL: T_CString_strnicmp(\"\", \"\") failed.  Expected:  0, returned %d\n", intValue);;
 153     }
 154     if((intValue=T_CString_strnicmp("", "abc", 10)) != -1){
 155         log_err("FAIL: T_CString_stricmp(\"\", \"abc\", 10) failed.  Expected: -1, returned %d\n", intValue);
 156     }
 157     if((intValue=T_CString_strnicmp("abc", "", 10)) != 1){
 158         log_err("FAIL: T_CString_strnicmp(\"abc\", \"\", 10) failed.  Expected: 1, returned %d\n", intValue);
 159     }
 160
 161 }
 162
 163 /* test invariant-character handling */
 164 static void
 165 TestInvariant() {
 166     /* all invariant graphic chars and some control codes (not \n!) */
 167     const char invariantChars[]=
 168         "\t\r \"%&'()*+,-./"
 169         "0123456789:;<=>?"
 170         "ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
 171         "abcdefghijklmnopqrstuvwxyz";
 172
 173     const UChar invariantUChars[]={
 174         9, 0xd, 0x20, 0x22, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 175         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 176         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 177         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5f,
 178         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 179         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0
 180     };
 181
 182     const char variantChars[]="\n!#$@[\\]^`{|}~";
 183
 184     const UChar variantUChars[]={
 185         0x0a, 0x21, 0x23, 0x24, 0x40, 0x5b, 0x5c, 0x5d, 0x5e, 0x60, 0x7b, 0x7c, 0x7d, 0x7e, 0
 186     };
 187
 188     const UChar nonASCIIUChars[]={ 0x80, 0xa0, 0x900, 0xff51 };
 189
 190     UChar us[120];
 191     char cs[120];
 192
 193     int32_t i, length;
 194
 195     /* make sure that all invariant characters convert both ways */
 196     length=sizeof(invariantChars);
 197     u_charsToUChars(invariantChars, us, length);
 198     if(u_strcmp(us, invariantUChars)!=0) {
 199         log_err("u_charsToUChars(invariantChars) failed\n");
 200     }
 201
 202     u_UCharsToChars(invariantUChars, cs, length);
 203     if(strcmp(cs, invariantChars)!=0) {
 204         log_err("u_UCharsToChars(invariantUChars) failed\n");
 205     }
 206
 207
 208     /*
 209      * make sure that variant characters convert from source code literals to Unicode
 210      * but not back to char *
 211      */
 212     length=sizeof(variantChars);
 213     u_charsToUChars(variantChars, us, length);
 214     if(u_strcmp(us, variantUChars)!=0) {
 215         log_err("u_charsToUChars(variantChars) failed\n");
 216     }
 217
 218 #ifdef NDEBUG
 219     /*
 220      * Test u_UCharsToChars(variantUChars) only in release mode because it will
 221      * cause an assertion failure in debug builds.
 222      */
 223     u_UCharsToChars(variantUChars, cs, length);
 224     for(i=0; i<length; ++i) {
 225         if(cs[i]!=0) {
 226             log_err("u_UCharsToChars(variantUChars) converted the %d-th character to %02x instead of 00\n", i, cs[i]);
 227         }
 228     }
 229 #endif
 230
 231     /*
 232      * Verify that invariant characters roundtrip from Unicode to the
 233      * default converter and back.
 234      */
 235     {
 236         UConverter *cnv;
 237         UErrorCode errorCode;
 238
 239         errorCode=U_ZERO_ERROR;
 240         cnv=ucnv_open(NULL, &errorCode);
 241         if(U_FAILURE(errorCode)) {
 242             log_err("unable to open the default converter\n");
 243         } else {
 244             length=ucnv_fromUChars(cnv, cs, sizeof(cs), invariantUChars, -1, &errorCode);
 245             if(U_FAILURE(errorCode)) {
 246                 log_err("ucnv_fromUChars(invariantUChars) failed - %s\n", u_errorName(errorCode));
 247             } else if(length!=sizeof(invariantChars)-1 || strcmp(cs, invariantChars)!=0) {
 248                 log_err("ucnv_fromUChars(invariantUChars) failed\n");
 249             }
 250
 251             errorCode=U_ZERO_ERROR;
 252             length=ucnv_toUChars(cnv, us, LENGTHOF(us), invariantChars, -1, &errorCode);
 253             if(U_FAILURE(errorCode)) {
 254                 log_err("ucnv_toUChars(invariantChars) failed - %s\n", u_errorName(errorCode));
 255             } else if(length!=LENGTHOF(invariantUChars)-1 || u_strcmp(us, invariantUChars)!=0) {
 256                 log_err("ucnv_toUChars(invariantChars) failed\n");
 257             }
 258
 259             ucnv_close(cnv);
 260         }
 261     }
 262
 263     /* API tests */
 264     if(!uprv_isInvariantString(invariantChars, -1)) {
 265         log_err("uprv_isInvariantString(invariantChars) failed\n");
 266     }
 267     if(!uprv_isInvariantUString(invariantUChars, -1)) {
 268         log_err("uprv_isInvariantUString(invariantUChars) failed\n");
 269     }
 270     if(!uprv_isInvariantString(invariantChars+strlen(invariantChars), 1)) {
 271         log_err("uprv_isInvariantString(\"\\0\") failed\n");
 272     }
 273
 274     for(i=0; i<(sizeof(variantChars)-1); ++i) {
 275         if(uprv_isInvariantString(variantChars+i, 1)) {
 276             log_err("uprv_isInvariantString(variantChars[%d]) failed\n", i);
 277         }
 278         if(uprv_isInvariantUString(variantUChars+i, 1)) {
 279             log_err("uprv_isInvariantUString(variantUChars[%d]) failed\n", i);
 280         }
 281     }
 282
 283     for(i=0; i<LENGTHOF(nonASCIIUChars); ++i) {
 284         if(uprv_isInvariantUString(nonASCIIUChars+i, 1)) {
 285             log_err("uprv_isInvariantUString(nonASCIIUChars[%d]) failed\n", i);
 286         }
 287     }
 288 }
 289
 290 static int32_t getSign(int32_t n) {
 291     if(n<0) {
 292         return -1;
 293     } else if(n==0) {
 294         return 0;
 295     } else {
 296         return 1;
 297     }
 298 }
 299
 300 static void
 301 TestCompareInvEbcdicAsAscii() {
 302     static const char *const invStrings[][2]={
 303         /* invariant-character strings in ascending ASCII order */
 304         /* EBCDIC       native */
 305         { "",             "" },
 306         { "\x6c",         "%" },
 307         { "\xf0",         "0" },
 308         { "\xf0\xf0",     "00" },
 309         { "\xf0\xf0\x81", "00a" },
 310         { "\x7e",         "=" },
 311         { "\xc1",         "A" },
 312         { "\xc1\xf0\xf0", "A00" },
 313         { "\xc1\xf0\xf0", "A00" },
 314         { "\xc1\xc1",     "AA" },
 315         { "\xc1\xc1\xf0", "AA0" },
 316         { "\x6d",         "_" },
 317         { "\x81",         "a" },
 318         { "\x81\xf0\xf0", "a00" },
 319         { "\x81\xf0\xf0", "a00" },
 320         { "\x81\x81",     "aa" },
 321         { "\x81\x81\xf0", "aa0" },
 322         { "\x81\x81\x81", "aaa" },
 323         { "\x81\x81\x82", "aab" }
 324     };
 325     int32_t i;
 326     for(i=1; i<LENGTHOF(invStrings); ++i) {
 327         int32_t diff1, diff2;
 328         /* compare previous vs. current */
 329         diff1=getSign(uprv_compareInvEbcdicAsAscii(invStrings[i-1][0], invStrings[i][0]));
 330         if(diff1>0 || (diff1==0 && 0!=uprv_strcmp(invStrings[i-1][0], invStrings[i][0]))) {
 331             log_err("uprv_compareInvEbcdicAsAscii(%s, %s)=%hd is wrong\n",
 332                     invStrings[i-1][1], invStrings[i][1], (short)diff1);
 333         }
 334         /* compare current vs. previous, should be inverse diff */
 335         diff2=getSign(uprv_compareInvEbcdicAsAscii(invStrings[i][0], invStrings[i-1][0]));
 336         if(diff2!=-diff1) {
 337             log_err("uprv_compareInvEbcdicAsAscii(%s, %s)=%hd is wrong\n",
 338                     invStrings[i][1], invStrings[i-1][1], (short)diff2);
 339         }
 340     }
 341 }