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); }