icuSources/test/cintltst/cstrtest.c

   1 /*
   2 **********************************************************************
   3 * Copyright (C) 1998-2004, 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
  30 void addCStringTest(TestNode** root) {
  31     addTest(root, &TestAPI,   "tsutil/cstrtest/TestAPI");
  32     addTest(root, &TestInvariant,   "tsutil/cstrtest/TestInvariant");
  33 }
  34
  35 static void TestAPI(void)
  36 {
  37     int32_t intValue=0;
  38     char src[30]="HELLO THERE", dest[30];
  39     static const char *const abc="abcdefghijklmnopqrstuvwxyz", *const ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  40     const char *temp;
  41     int32_t i;
  42
  43     log_verbose("Testing uprv_tolower() and uprv_toupper()\n");
  44     for(i=0; i<=26; ++i) {
  45         dest[i]=uprv_tolower(abc[i]);
  46     }
  47     if(0!=strcmp(abc, dest)) {
  48         log_err("uprv_tolower(abc) failed\n");
  49     }
  50
  51     for(i=0; i<=26; ++i) {
  52         dest[i]=uprv_tolower(ABC[i]);
  53     }
  54     if(0!=strcmp(abc, dest)) {
  55         log_err("uprv_tolower(ABC) failed\n");
  56     }
  57
  58     for(i=0; i<=26; ++i) {
  59         dest[i]=uprv_toupper(abc[i]);
  60     }
  61     if(0!=strcmp(ABC, dest)) {
  62         log_err("uprv_toupper(abc) failed\n");
  63     }
  64
  65     for(i=0; i<=26; ++i) {
  66         dest[i]=uprv_toupper(ABC[i]);
  67     }
  68     if(0!=strcmp(ABC, dest)) {
  69         log_err("uprv_toupper(ABC) failed\n");
  70     }
  71
  72     log_verbose("Testing the API in cstring\n");
  73     T_CString_toLowerCase(src);
  74     if(uprv_strcmp(src, "hello there") != 0){
  75         log_err("FAIL: *** T_CString_toLowerCase() failed. Expected: \"hello there\", Got: \"%s\"\n", src);
  76     }
  77     T_CString_toUpperCase(src);
  78     if(uprv_strcmp(src, "HELLO THERE") != 0){
  79         log_err("FAIL: *** T_CString_toUpperCase() failed. Expected: \"HELLO THERE\", Got: \"%s\"\n", src);
  80     }
  81
  82     intValue=T_CString_stringToInteger("34556", 10);
  83     if(intValue != 34556){
  84         log_err("FAIL: ****T_CString_stringToInteger(\"34556\", 10) failed. Expected: 34556, Got: %d\n", intValue);
  85     }
  86     intValue=T_CString_stringToInteger("100", 16);
  87     if(intValue != 256){
  88         log_err("FAIL: ****T_CString_stringToInteger(\"100\", 16) failed. Expected: 256, Got: %d\n", intValue);
  89     }
  90     i = T_CString_integerToString(src, 34556, 10);
  91     if(uprv_strcmp(src, "34556") != 0 || i != 5){
  92         log_err("FAIL: ****integerToString(src, 34566, 10); failed. Expected: \"34556\", Got: %s\n", src);
  93     }
  94     i = T_CString_integerToString(src, 431, 16);
  95     if(uprv_stricmp(src, "1AF") != 0 || i != 3){
  96         log_err("FAIL: ****integerToString(src, 431, 16); failed. Expected: \"1AF\", Got: %s\n", src);
  97     }
  98
  99     uprv_strcpy(src, "this is lower case");
 100     if(T_CString_stricmp(src, "THIS is lower CASE") != 0){
 101         log_err("FAIL: *****T_CString_stricmp() failed.");
 102     }
 103     if((intValue=T_CString_stricmp(NULL, "first string is null") )!= -1){
 104         log_err("FAIL: T_CString_stricmp() where the first string is null failed. Expected: -1, returned %d\n", intValue);
 105     }
 106     if((intValue=T_CString_stricmp("second string is null", NULL)) != 1){
 107         log_err("FAIL: T_CString_stricmp() where the second string is null failed. Expected: 1, returned %d\n", intValue);
 108     }
 109     if((intValue=T_CString_stricmp(NULL, NULL)) != 0){
 110         log_err("FAIL: T_CString_stricmp(NULL, NULL) failed.  Expected:  0, returned %d\n", intValue);;
 111     }
 112     if((intValue=T_CString_stricmp("", "")) != 0){
 113         log_err("FAIL: T_CString_stricmp(\"\", \"\") failed.  Expected:  0, returned %d\n", intValue);;
 114     }
 115     if((intValue=T_CString_stricmp("", "abc")) != -1){
 116         log_err("FAIL: T_CString_stricmp(\"\", \"abc\") failed.  Expected: -1, returned %d\n", intValue);
 117     }
 118     if((intValue=T_CString_stricmp("abc", "")) != 1){
 119         log_err("FAIL: T_CString_stricmp(\"abc\", \"\") failed.  Expected: 1, returned %d\n", intValue);
 120     }
 121
 122     temp=uprv_strdup("strdup");
 123     if(uprv_strcmp(temp, "strdup") !=0 ){
 124         log_err("FAIL: uprv_strdup() failed. Expected: \"strdup\", Got: %s\n", temp);
 125     }
 126     uprv_free((char *)temp);
 127
 128     uprv_strcpy(src, "this is lower case");
 129     if(T_CString_strnicmp(src, "THIS", 4 ) != 0){
 130         log_err("FAIL: *****T_CString_strnicmp() failed.");
 131     }
 132     if((intValue=T_CString_strnicmp(NULL, "first string is null", 10) )!= -1){
 133         log_err("FAIL: T_CString_strnicmp() where the first string is null failed. Expected: -1, returned %d\n", intValue);
 134     }
 135     if((intValue=T_CString_strnicmp("second string is null", NULL, 10)) != 1){
 136         log_err("FAIL: T_CString_strnicmp() where the second string is null failed. Expected: 1, returned %d\n", intValue);
 137     }
 138     if((intValue=T_CString_strnicmp(NULL, NULL, 10)) != 0){
 139         log_err("FAIL: T_CString_strnicmp(NULL, NULL, 10) failed.  Expected:  0, returned %d\n", intValue);;
 140     }
 141     if((intValue=T_CString_strnicmp("", "", 10)) != 0){
 142         log_err("FAIL: T_CString_strnicmp(\"\", \"\") failed.  Expected:  0, returned %d\n", intValue);;
 143     }
 144     if((intValue=T_CString_strnicmp("", "abc", 10)) != -1){
 145         log_err("FAIL: T_CString_stricmp(\"\", \"abc\", 10) failed.  Expected: -1, returned %d\n", intValue);
 146     }
 147     if((intValue=T_CString_strnicmp("abc", "", 10)) != 1){
 148         log_err("FAIL: T_CString_strnicmp(\"abc\", \"\", 10) failed.  Expected: 1, returned %d\n", intValue);
 149     }
 150
 151 }
 152
 153 /* test invariant-character handling */
 154 static void
 155 TestInvariant() {
 156     /* all invariant graphic chars and some control codes (not \n!) */
 157     const char invariantChars[]=
 158         "\t\r \"%&'()*+,-./"
 159         "0123456789:;<=>?"
 160         "ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
 161         "abcdefghijklmnopqrstuvwxyz";
 162
 163     const UChar invariantUChars[]={
 164         9, 0xd, 0x20, 0x22, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 165         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 166         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 167         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5f,
 168         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 169         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0
 170     };
 171
 172     const char variantChars[]="\n!#$@[\\]^`{|}~";
 173
 174     const UChar variantUChars[]={
 175         0x0a, 0x21, 0x23, 0x24, 0x40, 0x5b, 0x5c, 0x5d, 0x5e, 0x60, 0x7b, 0x7c, 0x7d, 0x7e, 0
 176     };
 177
 178     const UChar nonASCIIUChars[]={ 0x80, 0xa0, 0x900, 0xff51 };
 179
 180     UChar us[120];
 181     char cs[120];
 182
 183     int32_t i, length;
 184
 185     /* make sure that all invariant characters convert both ways */
 186     length=sizeof(invariantChars);
 187     u_charsToUChars(invariantChars, us, length);
 188     if(u_strcmp(us, invariantUChars)!=0) {
 189         log_err("u_charsToUChars(invariantChars) failed\n");
 190     }
 191
 192     u_UCharsToChars(invariantUChars, cs, length);
 193     if(strcmp(cs, invariantChars)!=0) {
 194         log_err("u_UCharsToChars(invariantUChars) failed\n");
 195     }
 196
 197
 198     /*
 199      * make sure that variant characters convert from source code literals to Unicode
 200      * but not back to char *
 201      */
 202     length=sizeof(variantChars);
 203     u_charsToUChars(variantChars, us, length);
 204     if(u_strcmp(us, variantUChars)!=0) {
 205         log_err("u_charsToUChars(variantChars) failed\n");
 206     }
 207
 208 #ifdef NDEBUG
 209     /*
 210      * Test u_UCharsToChars(variantUChars) only in release mode because it will
 211      * cause an assertion failure in debug builds.
 212      */
 213     u_UCharsToChars(variantUChars, cs, length);
 214     for(i=0; i<length; ++i) {
 215         if(cs[i]!=0) {
 216             log_err("u_UCharsToChars(variantUChars) converted the %d-th character to %02x instead of 00\n", i, cs[i]);
 217         }
 218     }
 219 #endif
 220
 221     /*
 222      * Verify that invariant characters roundtrip from Unicode to the
 223      * default converter and back.
 224      */
 225     {
 226         UConverter *cnv;
 227         UErrorCode errorCode;
 228
 229         errorCode=U_ZERO_ERROR;
 230         cnv=ucnv_open(NULL, &errorCode);
 231         if(U_FAILURE(errorCode)) {
 232             log_err("unable to open the default converter\n");
 233         } else {
 234             length=ucnv_fromUChars(cnv, cs, sizeof(cs), invariantUChars, -1, &errorCode);
 235             if(U_FAILURE(errorCode)) {
 236                 log_err("ucnv_fromUChars(invariantUChars) failed - %s\n", u_errorName(errorCode));
 237             } else if(length!=sizeof(invariantChars)-1 || strcmp(cs, invariantChars)!=0) {
 238                 log_err("ucnv_fromUChars(invariantUChars) failed\n");
 239             }
 240
 241             errorCode=U_ZERO_ERROR;
 242             length=ucnv_toUChars(cnv, us, LENGTHOF(us), invariantChars, -1, &errorCode);
 243             if(U_FAILURE(errorCode)) {
 244                 log_err("ucnv_toUChars(invariantChars) failed - %s\n", u_errorName(errorCode));
 245             } else if(length!=LENGTHOF(invariantUChars)-1 || u_strcmp(us, invariantUChars)!=0) {
 246                 log_err("ucnv_toUChars(invariantChars) failed\n");
 247             }
 248
 249             ucnv_close(cnv);
 250         }
 251     }
 252
 253     /* API tests */
 254     if(!uprv_isInvariantString(invariantChars, -1)) {
 255         log_err("uprv_isInvariantString(invariantChars) failed\n");
 256     }
 257     if(!uprv_isInvariantUString(invariantUChars, -1)) {
 258         log_err("uprv_isInvariantUString(invariantUChars) failed\n");
 259     }
 260
 261     for(i=0; i<(sizeof(variantChars)-1); ++i) {
 262         if(uprv_isInvariantString(variantChars+i, 1)) {
 263             log_err("uprv_isInvariantString(variantChars[%d]) failed\n", i);
 264         }
 265         if(uprv_isInvariantUString(variantUChars+i, 1)) {
 266             log_err("uprv_isInvariantUString(variantUChars[%d]) failed\n", i);
 267         }
 268     }
 269
 270     for(i=0; i<LENGTHOF(nonASCIIUChars); ++i) {
 271         if(uprv_isInvariantUString(nonASCIIUChars+i, 1)) {
 272             log_err("uprv_isInvariantUString(nonASCIIUChars[%d]) failed\n", i);
 273         }
 274     }
 275 }