308 lines
8.0 KiB
C
308 lines
8.0 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* 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");
|
|
}
|