Home | History | Annotate | Download | only in cintltst 
      1 /*
      2 *******************************************************************************
      3 *
      4 *   Copyright (C) 2002-2003, 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 void addEnumerationTest(TestNode** root);
    301 
    302 void addEnumerationTest(TestNode** root)
    303 {
    304     addTest(root, &EnumerationTest, "tsutil/uenumtst/EnumerationTest");
    305     addTest(root, &EmptyEnumerationTest, "tsutil/uenumtst/EmptyEnumerationTest");
    306     addTest(root, &DefaultNextTest, "tsutil/uenumtst/DefaultNextTest");
    307 }
    308