static void _expectRules(const char* crules,
const char* cfrom,
const char* cto) {
/* u_uastrcpy has no capacity param for the buffer -- so just
* make all buffers way too big */
enum { CAP = 256 };
UChar rules[CAP];
UTransliterator *trans;
UErrorCode status = U_ZERO_ERROR;
UParseError parseErr;
u_uastrcpy(rules, crules);
trans = utrans_open(crules /*use rules as ID*/, UTRANS_FORWARD, rules, -1,
&parseErr, &status);
if (U_FAILURE(status)) {
utrans_close(trans);
log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n",
crules, u_errorName(status));
return;
}
_expect(trans, cfrom, cto);
utrans_close(trans);
}
static void test_fts_icu_translate_resize(void)
{
const char *translit_id = "Any-Hex";
const char *src_utf8 = "FOO";
buffer_t *dest, *src_utf16;
UTransliterator *translit;
const char *error;
unsigned int i;
test_begin("fts_icu_translate_resize resize");
src_utf16 = buffer_create_dynamic(pool_datastack_create(), 16);
translit = get_translit(translit_id);
for (i = 2; i <= 20; i++) {
buffer_set_used_size(src_utf16, 0);
fts_icu_utf8_to_utf16(src_utf16, src_utf8);
dest = buffer_create_dynamic(pool_datastack_create(), i);
test_assert(buffer_get_size(dest) == i);
test_assert(fts_icu_translate(dest, src_utf16->data,
src_utf16->used/sizeof(UChar),
translit, &error) == 0);
}
utrans_close(translit);
test_end();
}
static void TestDataVariantsCompounds() {
const TransIDSourceTarg* itemsPtr;
for (itemsPtr = dataVarCompItems; itemsPtr->transID != NULL; itemsPtr++) {
UErrorCode status = U_ZERO_ERROR;
UChar utrid[kUBufMax];
int32_t utridlen = u_unescape(itemsPtr->transID, utrid, kUBufMax);
UTransliterator* utrans = utrans_openU(utrid, utridlen, UTRANS_FORWARD, NULL, 0, NULL, &status);
if (U_FAILURE(status)) {
log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n", itemsPtr->transID, u_errorName(status));
continue;
}
UChar text[kUBufMax];
int32_t textLen = u_unescape(itemsPtr->sourceText, text, kUBufMax);
int32_t textLim = textLen;
utrans_transUChars(utrans, text, &textLen, kUBufMax, 0, &textLim, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_transUChars(%s) failed, error=%s\n", itemsPtr->transID, u_errorName(status));
} else {
UChar expect[kUBufMax];
int32_t expectLen = u_unescape(itemsPtr->targetText, expect, kUBufMax);
if (textLen != expectLen || u_strncmp(text, expect, textLen) != 0) {
char btext[kBBufMax], bexpect[kBBufMax];
u_austrncpy(btext, text, textLen);
u_austrncpy(bexpect, expect, expectLen);
log_err("FAIL: utrans_transUChars(%s),\n expect %s\n get %s\n", itemsPtr->transID, bexpect, btext);
}
}
utrans_close(utrans);
}
}
static void TestOpenInverse() {
UErrorCode status=U_ZERO_ERROR;
UTransliterator* t1=NULL;
UTransliterator* inverse1=NULL;
enum { BUF_CAP = 128 };
char buf1[BUF_CAP];
int32_t i=0;
const char TransID[][25]= {
"Halfwidth-Fullwidth",
"Fullwidth-Halfwidth",
"Greek-Latin" ,
"Latin-Greek",
/*"Arabic-Latin", // Removed in 2.0*/
/*"Latin-Arabic", // Removed in 2.0*/
"Katakana-Latin",
"Latin-Katakana",
/*"Hebrew-Latin", // Removed in 2.0*/
/*"Latin-Hebrew", // Removed in 2.0*/
"Cyrillic-Latin",
"Latin-Cyrillic",
"Devanagari-Latin",
"Latin-Devanagari",
"Any-Hex",
"Hex-Any"
};
for(i=0; i<sizeof(TransID)/sizeof(TransID[0]); i=i+2) {
status = U_ZERO_ERROR;
t1=utrans_open(TransID[i], UTRANS_FORWARD,NULL,0,NULL, &status);
if(t1 == NULL || U_FAILURE(status)) {
log_data_err("FAIL: in instantiation for id=%s -> %s (Are you missing data?)\n", TransID[i], u_errorName(status));
continue;
}
inverse1=utrans_openInverse(t1, &status);
if(U_FAILURE(status)) {
log_err("FAIL: utrans_openInverse() failed for id=%s. Error=%s\n", TransID[i], myErrorName(status));
continue;
}
utrans_getID(inverse1, buf1, BUF_CAP);
if(strcmp(buf1, TransID[i+1]) != 0) {
log_err("FAIL :openInverse() for %s returned %s instead of %s\n", TransID[i], buf1, TransID[i+1]);
}
utrans_close(t1);
utrans_close(inverse1);
}
}
static void TestClone() {
UErrorCode status=U_ZERO_ERROR;
UTransliterator* t1=NULL;
UTransliterator* t2=NULL;
UTransliterator* t3=NULL;
UTransliterator* t4=NULL;
enum { BUF_CAP = 128 };
char buf1[BUF_CAP], buf2[BUF_CAP], buf3[BUF_CAP];
t1=utrans_open("Latin-Devanagari", UTRANS_FORWARD, NULL,0,NULL,&status);
if(U_FAILURE(status)) {
log_data_err("FAIL: construction -> %s (Are you missing data?)\n", u_errorName(status));
return;
}
t2=utrans_open("Latin-Greek", UTRANS_FORWARD, NULL,0,NULL,&status);
if(U_FAILURE(status)) {
log_err("FAIL: construction\n");
utrans_close(t1);
return;
}
t3=utrans_clone(t1, &status);
t4=utrans_clone(t2, &status);
utrans_getID(t1, buf1, BUF_CAP);
utrans_getID(t2, buf2, BUF_CAP);
utrans_getID(t3, buf3, BUF_CAP);
if(strcmp(buf1, buf3) != 0 ||
strcmp(buf1, buf2) == 0) {
log_err("FAIL: utrans_clone() failed\n");
}
utrans_getID(t4, buf3, BUF_CAP);
if(strcmp(buf2, buf3) != 0 ||
strcmp(buf1, buf3) == 0) {
log_err("FAIL: utrans_clone() failed\n");
}
utrans_close(t1);
utrans_close(t2);
utrans_close(t3);
utrans_close(t4);
}
static void
transliterator_icu_finalize (GObject *object)
{
TransliteratorIcu *icu = TRANSLITERATOR_ICU (object);
utrans_close (icu->trans);
G_OBJECT_CLASS (transliterator_icu_parent_class)->finalize (object);
}
static void TestGetRulesAndSourceSet() {
UErrorCode status = U_ZERO_ERROR;
UTransliterator *utrans = utrans_openU(transSimpleID, -1, UTRANS_FORWARD, NULL, 0, NULL, &status);
if ( U_SUCCESS(status) ) {
USet* uset;
UChar ubuf[kUBufMax];
int32_t ulen;
status = U_ZERO_ERROR;
ulen = utrans_toRules(utrans, FALSE, ubuf, kUBufMax, &status);
if ( U_FAILURE(status) || ulen <= 50 || ulen >= 100) {
log_err("FAIL: utrans_toRules unescaped, expected noErr and len 50-100, got error=%s and len=%d\n",
u_errorName(status), ulen);
}
status = U_ZERO_ERROR;
ulen = utrans_toRules(utrans, FALSE, NULL, 0, &status);
if ( status != U_BUFFER_OVERFLOW_ERROR || ulen <= 50 || ulen >= 100) {
log_err("FAIL: utrans_toRules unescaped, expected U_BUFFER_OVERFLOW_ERROR and len 50-100, got error=%s and len=%d\n",
u_errorName(status), ulen);
}
status = U_ZERO_ERROR;
ulen = utrans_toRules(utrans, TRUE, ubuf, kUBufMax, &status);
if ( U_FAILURE(status) || ulen <= 100 || ulen >= 200) {
log_err("FAIL: utrans_toRules escaped, expected noErr and len 100-200, got error=%s and len=%d\n",
u_errorName(status), ulen);
}
status = U_ZERO_ERROR;
uset = utrans_getSourceSet(utrans, FALSE, NULL, &status);
ulen = uset_toPattern(uset, ubuf, kUBufMax, FALSE, &status);
uset_close(uset);
if ( U_FAILURE(status) || ulen <= 4 || ulen >= 20) {
log_err("FAIL: utrans_getSourceSet useFilter, expected noErr and len 4-20, got error=%s and len=%d\n",
u_errorName(status), ulen);
}
status = U_ZERO_ERROR;
uset = utrans_getSourceSet(utrans, TRUE, NULL, &status);
ulen = uset_toPattern(uset, ubuf, kUBufMax, FALSE, &status);
uset_close(uset);
if ( U_FAILURE(status) || ulen <= 4 || ulen >= 20) {
log_err("FAIL: utrans_getSourceSet ignoreFilter, expected noErr and len 4-20, got error=%s and len=%d\n",
u_errorName(status), ulen);
}
utrans_close(utrans);
} else {
log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n",
transSimpleCName, u_errorName(status));
}
}
/* {{{ void transliterator_object_destroy( Transliterator_object* to )
* Clean up mem allocted by internals of Transliterator_object
*/
static void transliterator_object_destroy( Transliterator_object* to )
{
if( !to )
return;
if( to->utrans )
{
utrans_close( to->utrans );
to->utrans = NULL;
}
intl_error_reset( TRANSLITERATOR_ERROR_P( to ) );
}
/**
* Test the UReplaceableCallback extractBetween support. We use a
* transliterator known to rely on this call.
*/
static void TestExtractBetween() {
UTransliterator *trans;
UErrorCode status = U_ZERO_ERROR;
UParseError parseErr;
trans = utrans_open("Lower", UTRANS_FORWARD, NULL, -1,
&parseErr, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_open(Lower) failed, error=%s\n",
u_errorName(status));
} else {
_expect(trans, "ABC", "abc");
utrans_close(trans);
}
}
static void test_fts_icu_translate(void)
{
const char *translit_id = "Any-Lower";
UTransliterator *translit;
buffer_t *dest = buffer_create_dynamic(pool_datastack_create(), 64);
const UChar src[] = { 0xbd, 'B', 'C' };
const char *error;
unsigned int i;
test_begin("fts_icu_translate");
translit = get_translit(translit_id);
for (i = N_ELEMENTS(src); i > 0; i--) {
buffer_set_used_size(dest, 0);
test_assert(fts_icu_translate(dest, src, i,
translit, &error) == 0);
test_assert(dest->used == i * sizeof(UChar));
}
utrans_close(translit);
test_end();
}
static void TestAPI() {
enum { BUF_CAP = 128 };
char buf[BUF_CAP], buf2[BUF_CAP];
UErrorCode status = U_ZERO_ERROR;
UTransliterator* trans = NULL;
int32_t i, n;
/* Test getAvailableIDs */
n = utrans_countAvailableIDs();
if (n < 1) {
log_err("FAIL: utrans_countAvailableIDs() returned %d\n", n);
} else {
log_verbose("System ID count: %d\n", n);
}
for (i=0; i<n; ++i) {
utrans_getAvailableID(i, buf, BUF_CAP);
if (*buf == 0) {
log_err("FAIL: System transliterator %d: \"\"\n", i);
} else {
log_verbose("System transliterator %d: \"%s\"\n", i, buf);
}
}
/* Test open */
utrans_getAvailableID(0, buf, BUF_CAP);
trans = utrans_open(buf, UTRANS_FORWARD,NULL,0,NULL, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_open(%s) failed, error=%s\n",
buf, u_errorName(status));
}
else {
/* Test getID */
utrans_getID(trans, buf2, BUF_CAP);
if (0 != strcmp(buf, buf2)) {
log_err("FAIL: utrans_getID(%s) returned %s\n",
buf, buf2);
}
utrans_close(trans);
}
}
void
ufile_close_translit(UFILE *f)
{
#if !UCONFIG_NO_TRANSLITERATION
if((!f)||(!f->fTranslit))
return;
#endif
ufile_flush_translit(f);
#if !UCONFIG_NO_TRANSLITERATION
if(f->fTranslit->translit)
utrans_close(f->fTranslit->translit);
if(f->fTranslit->buffer)
{
uprv_free(f->fTranslit->buffer);
}
uprv_free(f->fTranslit);
f->fTranslit = NULL;
#endif
}
static void trans_free(void *trans) {
utrans_close(trans);
}
static void TestFilter() {
UErrorCode status = U_ZERO_ERROR;
UChar filt[128];
UChar buf[128];
UChar exp[128];
char *cbuf;
int32_t limit;
const char* DATA[] = {
"[^c]", /* Filter out 'c' */
"abcde",
"\\u0061\\u0062c\\u0064\\u0065",
"", /* No filter */
"abcde",
"\\u0061\\u0062\\u0063\\u0064\\u0065"
};
int32_t DATA_length = sizeof(DATA) / sizeof(DATA[0]);
int32_t i;
UTransliterator* hex = utrans_open("Any-Hex", UTRANS_FORWARD, NULL,0,NULL,&status);
if (hex == 0 || U_FAILURE(status)) {
log_err("FAIL: utrans_open(Unicode-Hex) failed, error=%s\n",
u_errorName(status));
goto exit;
}
for (i=0; i<DATA_length; i+=3) {
/*u_uastrcpy(filt, DATA[i]);*/
u_charsToUChars(DATA[i], filt, (int32_t)strlen(DATA[i])+1);
utrans_setFilter(hex, filt, -1, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_setFilter() failed, error=%s\n",
u_errorName(status));
goto exit;
}
/*u_uastrcpy(buf, DATA[i+1]);*/
u_charsToUChars(DATA[i+1], buf, (int32_t)strlen(DATA[i+1])+1);
limit = 5;
utrans_transUChars(hex, buf, NULL, 128, 0, &limit, &status);
if (U_FAILURE(status)) {
log_err("FAIL: utrans_transUChars() failed, error=%s\n",
u_errorName(status));
goto exit;
}
cbuf=aescstrdup(buf, -1);
u_charsToUChars(DATA[i+2], exp, (int32_t)strlen(DATA[i+2])+1);
if (0 == u_strcmp(buf, exp)) {
log_verbose("Ok: %s | %s -> %s\n", DATA[i+1], DATA[i], cbuf);
} else {
log_err("FAIL: %s | %s -> %s, expected %s\n", DATA[i+1], DATA[i], cbuf, DATA[i+2]);
}
}
exit:
utrans_close(hex);
}
static void TestRegisterUnregister() {
UErrorCode status=U_ZERO_ERROR;
UTransliterator* t1=NULL;
UTransliterator* rules=NULL, *rules2;
UTransliterator* inverse1=NULL;
UChar rule[]= { 0x0061, 0x003c, 0x003e, 0x0063}; /*a<>b*/
U_STRING_DECL(ID, "TestA-TestB", 11);
U_STRING_INIT(ID, "TestA-TestB", 11);
/* Make sure it doesn't exist */
t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
if(t1 != NULL || U_SUCCESS(status)) {
log_err("FAIL: TestA-TestB already registered\n");
return;
}
status=U_ZERO_ERROR;
/* Check inverse too */
inverse1=utrans_open("TestA-TestB", UTRANS_REVERSE, NULL,0,NULL,&status);
if(inverse1 != NULL || U_SUCCESS(status)) {
log_err("FAIL: TestA-TestB already registered\n");
return;
}
status=U_ZERO_ERROR;
/* Create it */
rules=utrans_open("TestA-TestB",UTRANS_FORWARD, rule, 4, NULL, &status);
if(U_FAILURE(status)) {
log_err("FAIL: utrans_openRules(a<>B) failed with error=%s\n", myErrorName(status));
return;
}
/* clone it so we can register it a second time */
rules2=utrans_clone(rules, &status);
if(U_FAILURE(status)) {
log_err("FAIL: utrans_clone(a<>B) failed with error=%s\n", myErrorName(status));
return;
}
status=U_ZERO_ERROR;
/* Register it */
utrans_register(rules, &status);
if(U_FAILURE(status)) {
log_err("FAIL: utrans_register failed with error=%s\n", myErrorName(status));
return;
}
status=U_ZERO_ERROR;
/* Now check again -- should exist now*/
t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
if(U_FAILURE(status) || t1 == NULL) {
log_err("FAIL: TestA-TestB not registered\n");
return;
}
utrans_close(t1);
/*unregister the instance*/
status=U_ZERO_ERROR;
utrans_unregister("TestA-TestB");
/* now Make sure it doesn't exist */
t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
if(U_SUCCESS(status) || t1 != NULL) {
log_err("FAIL: TestA-TestB isn't unregistered\n");
return;
}
utrans_close(t1);
/* now with utrans_unregisterID(const UChar *) */
status=U_ZERO_ERROR;
utrans_register(rules2, &status);
if(U_FAILURE(status)) {
log_err("FAIL: 2nd utrans_register failed with error=%s\n", myErrorName(status));
return;
}
status=U_ZERO_ERROR;
/* Now check again -- should exist now*/
t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
if(U_FAILURE(status) || t1 == NULL) {
log_err("FAIL: 2nd TestA-TestB not registered\n");
return;
}
utrans_close(t1);
/*unregister the instance*/
status=U_ZERO_ERROR;
utrans_unregisterID(ID, -1);
/* now Make sure it doesn't exist */
t1=utrans_openU(ID, -1, UTRANS_FORWARD,NULL,0,NULL, &status);
if(U_SUCCESS(status) || t1 != NULL) {
log_err("FAIL: 2nd TestA-TestB isn't unregistered\n");
return;
}
utrans_close(t1);
utrans_close(inverse1);
}
/* Called from cloner for each thread. */
static void trans_close(char* obj)
{
if (obj != NULL)
utrans_close((UTransliterator*) obj);
}
static void TestUnicodeIDs() {
UEnumeration *uenum;
UTransliterator *utrans;
const UChar *id, *id2;
int32_t idLength, id2Length, count, count2;
UErrorCode errorCode;
errorCode=U_ZERO_ERROR;
uenum=utrans_openIDs(&errorCode);
if(U_FAILURE(errorCode)) {
log_err("utrans_openIDs() failed - %s\n", u_errorName(errorCode));
return;
}
count=uenum_count(uenum, &errorCode);
if(U_FAILURE(errorCode) || count<1) {
log_err("uenum_count(transliterator IDs)=%d - %s\n", count, u_errorName(errorCode));
}
count=0;
for(;;) {
id=uenum_unext(uenum, &idLength, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("uenum_unext(transliterator ID %d) failed - %s\n", count, u_errorName(errorCode));
break;
}
if(id==NULL) {
break;
}
if(++count>10) {
/* try to actually open only a few transliterators */
continue;
}
utrans=utrans_openU(id, idLength, UTRANS_FORWARD, NULL, 0, NULL, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("utrans_openU(%s) failed - %s\n", aescstrdup(id, idLength), u_errorName(errorCode));
continue;
}
id2=utrans_getUnicodeID(utrans, &id2Length);
if(idLength!=id2Length || 0!=u_memcmp(id, id2, idLength)) {
log_err("utrans_getUnicodeID(%s) does not match the original ID\n", aescstrdup(id, idLength));
}
utrans_close(utrans);
}
uenum_reset(uenum, &errorCode);
if(U_FAILURE(errorCode) || count<1) {
log_err("uenum_reset(transliterator IDs) failed - %s\n", u_errorName(errorCode));
} else {
count2=uenum_count(uenum, &errorCode);
if(U_FAILURE(errorCode) || count<1) {
log_err("2nd uenum_count(transliterator IDs)=%d - %s\n", count2, u_errorName(errorCode));
} else if(count!=count2) {
log_err("uenum_unext(transliterator IDs) returned %d IDs but uenum_count() after uenum_reset() claims there are %d\n", count, count2);
}
}
uenum_close(uenum);
}
