/* ******************************************************************************* * * Copyright (C) 2002-2003, International Business Machines * Corporation and others. All Rights Reserved. * ******************************************************************************* * file name: uenumtst.c * encoding: US-ASCII * tab size: 8 (not used) * indentation:2 * * created on: 2002jul08 * created by: Vladimir Weinstein */ #include "cintltst.h" #include "uenumimp.h" #include "cmemory.h" #include "cstring.h" #include "unicode/ustring.h" static char quikBuf[256]; static char* quikU2C(const UChar* str, int32_t len) { u_UCharsToChars(str, quikBuf, len); quikBuf[len] = 0; return quikBuf; } static const char* test1[] = { "first", "second", "third", "fourth" }; struct chArrayContext { int32_t currIndex; int32_t maxIndex; char *currChar; UChar *currUChar; char **array; }; typedef struct chArrayContext chArrayContext; #define cont ((chArrayContext *)en->context) static void U_CALLCONV chArrayClose(UEnumeration *en) { if(cont->currUChar != NULL) { free(cont->currUChar); cont->currUChar = NULL; } free(en); } static int32_t U_CALLCONV chArrayCount(UEnumeration *en, UErrorCode *status) { return cont->maxIndex; } static const UChar* U_CALLCONV chArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { if(cont->currIndex >= cont->maxIndex) { return NULL; } if(cont->currUChar == NULL) { cont->currUChar = (UChar *)malloc(1024*sizeof(UChar)); } cont->currChar = (cont->array)[cont->currIndex]; *resultLength = (int32_t)strlen(cont->currChar); u_charsToUChars(cont->currChar, cont->currUChar, *resultLength); cont->currIndex++; return cont->currUChar; } static const char* U_CALLCONV chArrayNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { if(cont->currIndex >= cont->maxIndex) { return NULL; } cont->currChar = (cont->array)[cont->currIndex]; *resultLength = (int32_t)strlen(cont->currChar); cont->currIndex++; return cont->currChar; } static void U_CALLCONV chArrayReset(UEnumeration *en, UErrorCode *status) { cont->currIndex = 0; } chArrayContext myCont = { 0, 0, NULL, NULL, NULL }; UEnumeration chEnum = { NULL, &myCont, chArrayClose, chArrayCount, chArrayUNext, chArrayNext, chArrayReset }; static const UEnumeration emptyEnumerator = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, }; static const UEnumeration emptyPartialEnumerator = { NULL, NULL, NULL, NULL, uenum_unextDefault, NULL, NULL, }; /********************************************************************/ static const UChar _first[] = {102,105,114,115,116,0}; /* "first" */ static const UChar _second[]= {115,101,99,111,110,100,0}; /* "second" */ static const UChar _third[] = {116,104,105,114,100,0}; /* "third" */ static const UChar _fourth[]= {102,111,117,114,116,104,0};/* "fourth" */ static const UChar* test2[] = { _first, _second, _third, _fourth }; struct uchArrayContext { int32_t currIndex; int32_t maxIndex; UChar *currUChar; UChar **array; }; typedef struct uchArrayContext uchArrayContext; #define ucont ((uchArrayContext *)en->context) static void U_CALLCONV uchArrayClose(UEnumeration *en) { free(en); } static int32_t U_CALLCONV uchArrayCount(UEnumeration *en, UErrorCode *status) { return ucont->maxIndex; } static const UChar* U_CALLCONV uchArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) { if(ucont->currIndex >= ucont->maxIndex) { return NULL; } ucont->currUChar = (ucont->array)[ucont->currIndex]; *resultLength = u_strlen(ucont->currUChar); ucont->currIndex++; return ucont->currUChar; } static void U_CALLCONV uchArrayReset(UEnumeration *en, UErrorCode *status) { ucont->currIndex = 0; } uchArrayContext myUCont = { 0, 0, NULL, NULL }; UEnumeration uchEnum = { NULL, &myUCont, uchArrayClose, uchArrayCount, uchArrayUNext, uenum_nextDefault, uchArrayReset }; /********************************************************************/ static UEnumeration *getchArrayEnum(const char** source, int32_t size) { UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration)); memcpy(en, &chEnum, sizeof(UEnumeration)); cont->array = (char **)source; cont->maxIndex = size; return en; } static void EnumerationTest(void) { UErrorCode status = U_ZERO_ERROR; int32_t len = 0; UEnumeration *en = getchArrayEnum(test1, sizeof(test1)/sizeof(test1[0])); const char *string = NULL; const UChar *uString = NULL; while ((string = uenum_next(en, &len, &status))) { log_verbose("read \"%s\", length %i\n", string, len); } uenum_reset(en, &status); while ((uString = uenum_unext(en, &len, &status))) { log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len); } uenum_close(en); } static void EmptyEnumerationTest(void) { UErrorCode status = U_ZERO_ERROR; UEnumeration *emptyEnum = uprv_malloc(sizeof(UEnumeration)); uprv_memcpy(emptyEnum, &emptyEnumerator, sizeof(UEnumeration)); if (uenum_count(emptyEnum, &status) != -1 || status != U_UNSUPPORTED_ERROR) { log_err("uenum_count failed\n"); } status = U_ZERO_ERROR; if (uenum_next(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { log_err("uenum_next failed\n"); } status = U_ZERO_ERROR; if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { log_err("uenum_unext failed\n"); } status = U_ZERO_ERROR; uenum_reset(emptyEnum, &status); if (status != U_UNSUPPORTED_ERROR) { log_err("uenum_reset failed\n"); } uenum_close(emptyEnum); status = U_ZERO_ERROR; if (uenum_next(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) { log_err("uenum_next(NULL) failed\n"); } status = U_ZERO_ERROR; if (uenum_unext(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) { log_err("uenum_unext(NULL) failed\n"); } status = U_ZERO_ERROR; uenum_reset(NULL, &status); if (status != U_ZERO_ERROR) { log_err("uenum_reset(NULL) failed\n"); } emptyEnum = uprv_malloc(sizeof(UEnumeration)); uprv_memcpy(emptyEnum, &emptyPartialEnumerator, sizeof(UEnumeration)); status = U_ZERO_ERROR; if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) { log_err("partial uenum_unext failed\n"); } uenum_close(emptyEnum); } static UEnumeration *getuchArrayEnum(const UChar** source, int32_t size) { UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration)); memcpy(en, &uchEnum, sizeof(UEnumeration)); ucont->array = (UChar **)source; ucont->maxIndex = size; return en; } static void DefaultNextTest(void) { UErrorCode status = U_ZERO_ERROR; int32_t len = 0; UEnumeration *en = getuchArrayEnum(test2, sizeof(test2)/sizeof(test2[0])); const char *string = NULL; const UChar *uString = NULL; while ((uString = uenum_unext(en, &len, &status))) { log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len); } if (U_FAILURE(status)) { log_err("FAIL: uenum_unext => %s\n", u_errorName(status)); } uenum_reset(en, &status); while ((string = uenum_next(en, &len, &status))) { log_verbose("read \"%s\", length %i\n", string, len); } if (U_FAILURE(status)) { log_err("FAIL: uenum_next => %s\n", u_errorName(status)); } uenum_close(en); } void addEnumerationTest(TestNode** root); void addEnumerationTest(TestNode** root) { addTest(root, &EnumerationTest, "tsutil/uenumtst/EnumerationTest"); addTest(root, &EmptyEnumerationTest, "tsutil/uenumtst/EmptyEnumerationTest"); addTest(root, &DefaultNextTest, "tsutil/uenumtst/DefaultNextTest"); }