1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2002-2012, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: uenumtst.c 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:2 12 * 13 * created on: 2002jul08 14 * created by: Vladimir Weinstein 15 */ 16 17 #include "cintltst.h" 18 #include "uenumimp.h" 19 #include "cmemory.h" 20 #include "cstring.h" 21 #include "unicode/ustring.h" 22 23 static char quikBuf[256]; 24 static char* quikU2C(const UChar* str, int32_t len) { 25 u_UCharsToChars(str, quikBuf, len); 26 quikBuf[len] = 0; 27 return quikBuf; 28 } 29 30 static const char* test1[] = { 31 "first", 32 "second", 33 "third", 34 "fourth" 35 }; 36 37 struct chArrayContext { 38 int32_t currIndex; 39 int32_t maxIndex; 40 char *currChar; 41 UChar *currUChar; 42 char **array; 43 }; 44 45 typedef struct chArrayContext chArrayContext; 46 47 #define cont ((chArrayContext *)en->context) 48 49 static void U_CALLCONV 50 chArrayClose(UEnumeration *en) { 51 if(cont->currUChar != NULL) { 52 free(cont->currUChar); 53 cont->currUChar = NULL; 54 } 55 free(en); 56 } 57 58 static int32_t U_CALLCONV 59 chArrayCount(UEnumeration *en, UErrorCode *status) { 60 return cont->maxIndex; 61 } 62 63 static const UChar* U_CALLCONV 64 chArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { 65 if(cont->currIndex >= cont->maxIndex) { 66 return NULL; 67 } 68 69 if(cont->currUChar == NULL) { 70 cont->currUChar = (UChar *)malloc(1024*sizeof(UChar)); 71 } 72 73 cont->currChar = (cont->array)[cont->currIndex]; 74 *resultLength = (int32_t)strlen(cont->currChar); 75 u_charsToUChars(cont->currChar, cont->currUChar, *resultLength); 76 cont->currIndex++; 77 return cont->currUChar; 78 } 79 80 static const char* U_CALLCONV 81 chArrayNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { 82 if(cont->currIndex >= cont->maxIndex) { 83 return NULL; 84 } 85 86 cont->currChar = (cont->array)[cont->currIndex]; 87 *resultLength = (int32_t)strlen(cont->currChar); 88 cont->currIndex++; 89 return cont->currChar; 90 } 91 92 static void U_CALLCONV 93 chArrayReset(UEnumeration *en, UErrorCode *status) { 94 cont->currIndex = 0; 95 } 96 97 chArrayContext myCont = { 98 0, 0, 99 NULL, NULL, 100 NULL 101 }; 102 103 UEnumeration chEnum = { 104 NULL, 105 &myCont, 106 chArrayClose, 107 chArrayCount, 108 chArrayUNext, 109 chArrayNext, 110 chArrayReset 111 }; 112 113 static const UEnumeration emptyEnumerator = { 114 NULL, 115 NULL, 116 NULL, 117 NULL, 118 NULL, 119 NULL, 120 NULL, 121 }; 122 123 static const UEnumeration emptyPartialEnumerator = { 124 NULL, 125 NULL, 126 NULL, 127 NULL, 128 uenum_unextDefault, 129 NULL, 130 NULL, 131 }; 132 133 /********************************************************************/ 134 static const UChar _first[] = {102,105,114,115,116,0}; /* "first" */ 135 static const UChar _second[]= {115,101,99,111,110,100,0}; /* "second" */ 136 static const UChar _third[] = {116,104,105,114,100,0}; /* "third" */ 137 static const UChar _fourth[]= {102,111,117,114,116,104,0};/* "fourth" */ 138 139 static const UChar* test2[] = { 140 _first, _second, _third, _fourth 141 }; 142 143 struct uchArrayContext { 144 int32_t currIndex; 145 int32_t maxIndex; 146 UChar *currUChar; 147 UChar **array; 148 }; 149 150 typedef struct uchArrayContext uchArrayContext; 151 152 #define ucont ((uchArrayContext *)en->context) 153 154 static void U_CALLCONV 155 uchArrayClose(UEnumeration *en) { 156 free(en); 157 } 158 159 static int32_t U_CALLCONV 160 uchArrayCount(UEnumeration *en, UErrorCode *status) { 161 return ucont->maxIndex; 162 } 163 164 static const UChar* U_CALLCONV 165 uchArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { 166 if(ucont->currIndex >= ucont->maxIndex) { 167 return NULL; 168 } 169 170 ucont->currUChar = (ucont->array)[ucont->currIndex]; 171 *resultLength = u_strlen(ucont->currUChar); 172 ucont->currIndex++; 173 return ucont->currUChar; 174 } 175 176 static void U_CALLCONV 177 uchArrayReset(UEnumeration *en, UErrorCode *status) { 178 ucont->currIndex = 0; 179 } 180 181 uchArrayContext myUCont = { 182 0, 0, 183 NULL, NULL 184 }; 185 186 UEnumeration uchEnum = { 187 NULL, 188 &myUCont, 189 uchArrayClose, 190 uchArrayCount, 191 uchArrayUNext, 192 uenum_nextDefault, 193 uchArrayReset 194 }; 195 196 /********************************************************************/ 197 198 static UEnumeration *getchArrayEnum(const char** source, int32_t size) { 199 UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration)); 200 memcpy(en, &chEnum, sizeof(UEnumeration)); 201 cont->array = (char **)source; 202 cont->maxIndex = size; 203 return en; 204 } 205 206 static void EnumerationTest(void) { 207 UErrorCode status = U_ZERO_ERROR; 208 int32_t len = 0; 209 UEnumeration *en = getchArrayEnum(test1, sizeof(test1)/sizeof(test1[0])); 210 const char *string = NULL; 211 const UChar *uString = NULL; 212 while ((string = uenum_next(en, &len, &status))) { 213 log_verbose("read \"%s\", length %i\n", string, len); 214 } 215 uenum_reset(en, &status); 216 while ((uString = uenum_unext(en, &len, &status))) { 217 log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len); 218 } 219 220 uenum_close(en); 221 } 222 223 static void EmptyEnumerationTest(void) { 224 UErrorCode status = U_ZERO_ERROR; 225 UEnumeration *emptyEnum = uprv_malloc(sizeof(UEnumeration)); 226 227 uprv_memcpy(emptyEnum, &emptyEnumerator, sizeof(UEnumeration)); 228 if (uenum_count(emptyEnum, &status) != -1 || status != U_UNSUPPORTED_ERROR) { 229 log_err("uenum_count failed\n"); 230 } 231 status = U_ZERO_ERROR; 232 if (uenum_next(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { 233 log_err("uenum_next failed\n"); 234 } 235 status = U_ZERO_ERROR; 236 if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { 237 log_err("uenum_unext failed\n"); 238 } 239 status = U_ZERO_ERROR; 240 uenum_reset(emptyEnum, &status); 241 if (status != U_UNSUPPORTED_ERROR) { 242 log_err("uenum_reset failed\n"); 243 } 244 uenum_close(emptyEnum); 245 246 status = U_ZERO_ERROR; 247 if (uenum_next(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) { 248 log_err("uenum_next(NULL) failed\n"); 249 } 250 status = U_ZERO_ERROR; 251 if (uenum_unext(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) { 252 log_err("uenum_unext(NULL) failed\n"); 253 } 254 status = U_ZERO_ERROR; 255 uenum_reset(NULL, &status); 256 if (status != U_ZERO_ERROR) { 257 log_err("uenum_reset(NULL) failed\n"); 258 } 259 260 emptyEnum = uprv_malloc(sizeof(UEnumeration)); 261 uprv_memcpy(emptyEnum, &emptyPartialEnumerator, sizeof(UEnumeration)); 262 status = U_ZERO_ERROR; 263 if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { 264 log_err("partial uenum_unext failed\n"); 265 } 266 uenum_close(emptyEnum); 267 } 268 269 static UEnumeration *getuchArrayEnum(const UChar** source, int32_t size) { 270 UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration)); 271 memcpy(en, &uchEnum, sizeof(UEnumeration)); 272 ucont->array = (UChar **)source; 273 ucont->maxIndex = size; 274 return en; 275 } 276 277 static void DefaultNextTest(void) { 278 UErrorCode status = U_ZERO_ERROR; 279 int32_t len = 0; 280 UEnumeration *en = getuchArrayEnum(test2, sizeof(test2)/sizeof(test2[0])); 281 const char *string = NULL; 282 const UChar *uString = NULL; 283 while ((uString = uenum_unext(en, &len, &status))) { 284 log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len); 285 } 286 if (U_FAILURE(status)) { 287 log_err("FAIL: uenum_unext => %s\n", u_errorName(status)); 288 } 289 uenum_reset(en, &status); 290 while ((string = uenum_next(en, &len, &status))) { 291 log_verbose("read \"%s\", length %i\n", string, len); 292 } 293 if (U_FAILURE(status)) { 294 log_err("FAIL: uenum_next => %s\n", u_errorName(status)); 295 } 296 297 uenum_close(en); 298 } 299 300 static void verifyEnumeration(int line, UEnumeration *u, const char * const * compareToChar, const UChar * const * compareToUChar, int32_t expect_count) { 301 UErrorCode status = U_ZERO_ERROR; 302 int32_t got_count,i,len; 303 const char *c; 304 UChar buf[1024]; 305 306 log_verbose("%s:%d: verifying enumeration..\n", __FILE__, line); 307 308 uenum_reset(u, &status); 309 if(U_FAILURE(status)) { 310 log_err("%s:%d: FAIL: could not reset char strings enumeration: %s\n", __FILE__, line, u_errorName(status)); 311 return; 312 } 313 314 got_count = uenum_count(u, &status); 315 if(U_FAILURE(status)) { 316 log_err("%s:%d: FAIL: could not count char strings enumeration: %s\n", __FILE__, line, u_errorName(status)); 317 return; 318 } 319 320 if(got_count!=expect_count) { 321 log_err("%s:%d: FAIL: expect count %d got %d\n", __FILE__, line, expect_count, got_count); 322 } else { 323 log_verbose("%s:%d: OK: got count %d\n", __FILE__, line, got_count); 324 } 325 326 if(compareToChar!=NULL) { /* else, not invariant */ 327 for(i=0;i<got_count;i++) { 328 c = uenum_next(u,&len, &status); 329 if(U_FAILURE(status)) { 330 log_err("%s:%d: FAIL: could not iterate to next after %d: %s\n", __FILE__, line, i, u_errorName(status)); 331 return; 332 } 333 if(c==NULL) { 334 log_err("%s:%d: FAIL: got NULL for next after %d: %s\n", __FILE__, line, i, u_errorName(status)); 335 return; 336 } 337 338 if(strcmp(c,compareToChar[i])) { 339 log_err("%s:%d: FAIL: string #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], c); 340 } else { 341 log_verbose("%s:%d: OK: string #%d got '%s'\n", __FILE__, line, i, c); 342 } 343 344 if(len!=strlen(compareToChar[i])) { 345 log_err("%s:%d: FAIL: string #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len); 346 } else { 347 log_verbose("%s:%d: OK: string #%d got len %d\n", __FILE__, line, i, len); 348 } 349 } 350 } 351 352 /* now try U */ 353 uenum_reset(u, &status); 354 if(U_FAILURE(status)) { 355 log_err("%s:%d: FAIL: could not reset again char strings enumeration: %s\n", __FILE__, line, u_errorName(status)); 356 return; 357 } 358 359 for(i=0;i<got_count;i++) { 360 const UChar *ustr = uenum_unext(u,&len, &status); 361 if(U_FAILURE(status)) { 362 log_err("%s:%d: FAIL: could not iterate to unext after %d: %s\n", __FILE__, line, i, u_errorName(status)); 363 return; 364 } 365 if(ustr==NULL) { 366 log_err("%s:%d: FAIL: got NULL for unext after %d: %s\n", __FILE__, line, i, u_errorName(status)); 367 return; 368 } 369 if(compareToChar!=NULL) { 370 u_charsToUChars(compareToChar[i], buf, strlen(compareToChar[i])+1); 371 if(u_strncmp(ustr,buf,len)) { 372 int j; 373 log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], austrdup(ustr)); 374 for(j=0;ustr[j]&&buf[j];j++) { 375 log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],buf[j]); 376 } 377 } else { 378 log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, compareToChar[i]); 379 } 380 381 if(len!=strlen(compareToChar[i])) { 382 log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len); 383 } else { 384 log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len); 385 } 386 } 387 388 if(compareToUChar!=NULL) { 389 if(u_strcmp(ustr,compareToUChar[i])) { 390 int j; 391 log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i]), austrdup(ustr)); 392 for(j=0;ustr[j]&&compareToUChar[j];j++) { 393 log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],compareToUChar[j]); 394 } 395 } else { 396 log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i])); 397 } 398 399 if(len!=u_strlen(compareToUChar[i])) { 400 log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, u_strlen(compareToUChar[i]), len); 401 } else { 402 log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len); 403 } 404 } 405 } 406 } 407 408 409 410 411 412 static void TestCharStringsEnumeration(void) { 413 UErrorCode status = U_ZERO_ERROR; 414 415 /* //! [uenum_openCharStringsEnumeration] */ 416 const char* strings[] = { "Firstly", "Secondly", "Thirdly", "Fourthly" }; 417 UEnumeration *u = uenum_openCharStringsEnumeration(strings, 4, &status); 418 /* //! [uenum_openCharStringsEnumeration] */ 419 if(U_FAILURE(status)) { 420 log_err("FAIL: could not open char strings enumeration: %s\n", u_errorName(status)); 421 return; 422 } 423 424 verifyEnumeration(__LINE__, u, strings, NULL, 4); 425 426 uenum_close(u); 427 } 428 429 static void TestUCharStringsEnumeration(void) { 430 UErrorCode status = U_ZERO_ERROR; 431 /* //! [uenum_openUCharStringsEnumeration] */ 432 static const UChar nko_1[] = {0x07c1,0}, nko_2[] = {0x07c2}, nko_3[] = {0x07c3,0}, nko_4[] = {0x07c4,0}; 433 static const UChar* ustrings[] = { nko_1, nko_2, nko_3, nko_4 }; 434 UEnumeration *u = uenum_openUCharStringsEnumeration(ustrings, 4, &status); 435 /* //! [uenum_openUCharStringsEnumeration] */ 436 if(U_FAILURE(status)) { 437 log_err("FAIL: could not open uchar strings enumeration: %s\n", u_errorName(status)); 438 return; 439 } 440 441 verifyEnumeration(__LINE__, u, NULL, ustrings, 4); 442 uenum_close(u); 443 444 445 u = uenum_openUCharStringsEnumeration(test2, 4, &status); 446 if(U_FAILURE(status)) { 447 log_err("FAIL: could not reopen uchar strings enumeration: %s\n", u_errorName(status)); 448 return; 449 } 450 verifyEnumeration(__LINE__, u, test1, NULL, 4); /* same string */ 451 uenum_close(u); 452 453 } 454 455 void addEnumerationTest(TestNode** root); 456 457 void addEnumerationTest(TestNode** root) 458 { 459 addTest(root, &EnumerationTest, "tsutil/uenumtst/EnumerationTest"); 460 addTest(root, &EmptyEnumerationTest, "tsutil/uenumtst/EmptyEnumerationTest"); 461 addTest(root, &DefaultNextTest, "tsutil/uenumtst/DefaultNextTest"); 462 addTest(root, &TestCharStringsEnumeration, "tsutil/uenumtst/TestCharStringsEnumeration"); 463 addTest(root, &TestUCharStringsEnumeration, "tsutil/uenumtst/TestUCharStringsEnumeration"); 464 } 465
