1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2009, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 *******************************************************************************
6 * Date Name Description
7 * 06/23/00 aliu Creation.
8 *******************************************************************************
9 */
10
11 #include "unicode/utypes.h"
12
13 #if !UCONFIG_NO_TRANSLITERATION
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include "unicode/utrans.h"
18 #include "unicode/ustring.h"
19 #include "cintltst.h"
20
21 #define TEST(x) addTest(root, &x, "utrans/" # x)
22
23 static void TestAPI(void);
24 static void TestSimpleRules(void);
25 static void TestFilter(void);
26 static void TestOpenInverse(void);
27 static void TestClone(void);
28 static void TestRegisterUnregister(void);
29 static void TestExtractBetween(void);
30 static void TestUnicodeIDs(void);
31
32 static void _expectRules(const char*, const char*, const char*);
33 static void _expect(const UTransliterator* trans, const char* cfrom, const char* cto);
34
35 void addUTransTest(TestNode** root);
36
37
38 void
addUTransTest(TestNode ** root)39 addUTransTest(TestNode** root) {
40 TEST(TestAPI);
41 TEST(TestSimpleRules);
42 TEST(TestFilter);
43 TEST(TestOpenInverse);
44 TEST(TestClone);
45 TEST(TestRegisterUnregister);
46 TEST(TestExtractBetween);
47 TEST(TestUnicodeIDs);
48 }
49
50 /*------------------------------------------------------------------
51 * Replaceable glue
52 *
53 * To test the Replaceable glue we have to dummy up a C-based
54 * Replaceable callback. This code is for testing purposes only.
55 *------------------------------------------------------------------*/
56
57 typedef struct XReplaceable {
58 UChar* text; /* MUST BE null-terminated */
59 } XReplaceable;
60
InitXReplaceable(XReplaceable * rep,const char * cstring)61 static void InitXReplaceable(XReplaceable* rep, const char* cstring) {
62 rep->text = malloc(sizeof(UChar) * (strlen(cstring)+1));
63 u_uastrcpy(rep->text, cstring);
64 }
65
FreeXReplaceable(XReplaceable * rep)66 static void FreeXReplaceable(XReplaceable* rep) {
67 if (rep->text != NULL) {
68 free(rep->text);
69 rep->text = NULL;
70 }
71 }
72
73 /* UReplaceableCallbacks callback */
Xlength(const UReplaceable * rep)74 static int32_t Xlength(const UReplaceable* rep) {
75 const XReplaceable* x = (const XReplaceable*)rep;
76 return u_strlen(x->text);
77 }
78
79 /* UReplaceableCallbacks callback */
XcharAt(const UReplaceable * rep,int32_t offset)80 static UChar XcharAt(const UReplaceable* rep, int32_t offset) {
81 const XReplaceable* x = (const XReplaceable*)rep;
82 return x->text[offset];
83 }
84
85 /* UReplaceableCallbacks callback */
Xchar32At(const UReplaceable * rep,int32_t offset)86 static UChar32 Xchar32At(const UReplaceable* rep, int32_t offset) {
87 const XReplaceable* x = (const XReplaceable*)rep;
88 return x->text[offset];
89 }
90
91 /* UReplaceableCallbacks callback */
Xreplace(UReplaceable * rep,int32_t start,int32_t limit,const UChar * text,int32_t textLength)92 static void Xreplace(UReplaceable* rep, int32_t start, int32_t limit,
93 const UChar* text, int32_t textLength) {
94 XReplaceable* x = (XReplaceable*)rep;
95 int32_t newLen = Xlength(rep) + limit - start + textLength;
96 UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
97 u_strncpy(newText, x->text, start);
98 u_strncpy(newText + start, text, textLength);
99 u_strcpy(newText + start + textLength, x->text + limit);
100 free(x->text);
101 x->text = newText;
102 }
103
104 /* UReplaceableCallbacks callback */
Xcopy(UReplaceable * rep,int32_t start,int32_t limit,int32_t dest)105 static void Xcopy(UReplaceable* rep, int32_t start, int32_t limit, int32_t dest) {
106 XReplaceable* x = (XReplaceable*)rep;
107 int32_t newLen = Xlength(rep) + limit - start;
108 UChar* newText = (UChar*) malloc(sizeof(UChar) * (newLen+1));
109 u_strncpy(newText, x->text, dest);
110 u_strncpy(newText + dest, x->text + start, limit - start);
111 u_strcpy(newText + dest + limit - start, x->text + dest);
112 free(x->text);
113 x->text = newText;
114 }
115
116 /* UReplaceableCallbacks callback */
Xextract(UReplaceable * rep,int32_t start,int32_t limit,UChar * dst)117 static void Xextract(UReplaceable* rep, int32_t start, int32_t limit, UChar* dst) {
118 XReplaceable* x = (XReplaceable*)rep;
119 int32_t len = limit - start;
120 u_strncpy(dst, x->text, len);
121 }
122
InitXReplaceableCallbacks(UReplaceableCallbacks * callbacks)123 static void InitXReplaceableCallbacks(UReplaceableCallbacks* callbacks) {
124 callbacks->length = Xlength;
125 callbacks->charAt = XcharAt;
126 callbacks->char32At = Xchar32At;
127 callbacks->replace = Xreplace;
128 callbacks->extract = Xextract;
129 callbacks->copy = Xcopy;
130 }
131
132 /*------------------------------------------------------------------
133 * Tests
134 *------------------------------------------------------------------*/
135
TestAPI()136 static void TestAPI() {
137 enum { BUF_CAP = 128 };
138 char buf[BUF_CAP], buf2[BUF_CAP];
139 UErrorCode status = U_ZERO_ERROR;
140 UTransliterator* trans = NULL;
141 int32_t i, n;
142
143 /* Test getAvailableIDs */
144 n = utrans_countAvailableIDs();
145 if (n < 1) {
146 log_err("FAIL: utrans_countAvailableIDs() returned %d\n", n);
147 } else {
148 log_verbose("System ID count: %d\n", n);
149 }
150 for (i=0; i<n; ++i) {
151 utrans_getAvailableID(i, buf, BUF_CAP);
152 if (*buf == 0) {
153 log_err("FAIL: System transliterator %d: \"\"\n", i);
154 } else {
155 log_verbose("System transliterator %d: \"%s\"\n", i, buf);
156 }
157 }
158
159 /* Test open */
160 utrans_getAvailableID(0, buf, BUF_CAP);
161 trans = utrans_open(buf, UTRANS_FORWARD,NULL,0,NULL, &status);
162 if (U_FAILURE(status)) {
163 log_err("FAIL: utrans_open(%s) failed, error=%s\n",
164 buf, u_errorName(status));
165 }
166
167 else {
168 /* Test getID */
169 utrans_getID(trans, buf2, BUF_CAP);
170 if (0 != strcmp(buf, buf2)) {
171 log_err("FAIL: utrans_getID(%s) returned %s\n",
172 buf, buf2);
173 }
174 utrans_close(trans);
175 }
176 }
177
TestUnicodeIDs()178 static void TestUnicodeIDs() {
179 UEnumeration *uenum;
180 UTransliterator *utrans;
181 const UChar *id, *id2;
182 int32_t idLength, id2Length, count, count2;
183
184 UErrorCode errorCode;
185
186 errorCode=U_ZERO_ERROR;
187 uenum=utrans_openIDs(&errorCode);
188 if(U_FAILURE(errorCode)) {
189 log_err("utrans_openIDs() failed - %s\n", u_errorName(errorCode));
190 return;
191 }
192
193 count=uenum_count(uenum, &errorCode);
194 if(U_FAILURE(errorCode) || count<1) {
195 log_err("uenum_count(transliterator IDs)=%d - %s\n", count, u_errorName(errorCode));
196 }
197
198 count=0;
199 for(;;) {
200 id=uenum_unext(uenum, &idLength, &errorCode);
201 if(U_FAILURE(errorCode)) {
202 log_err("uenum_unext(transliterator ID %d) failed - %s\n", count, u_errorName(errorCode));
203 break;
204 }
205 if(id==NULL) {
206 break;
207 }
208
209 if(++count>10) {
210 /* try to actually open only a few transliterators */
211 continue;
212 }
213
214 utrans=utrans_openU(id, idLength, UTRANS_FORWARD, NULL, 0, NULL, &errorCode);
215 if(U_FAILURE(errorCode)) {
216 log_err("utrans_openU(%s) failed - %s\n", aescstrdup(id, idLength), u_errorName(errorCode));
217 continue;
218 }
219
220 id2=utrans_getUnicodeID(utrans, &id2Length);
221 if(idLength!=id2Length || 0!=u_memcmp(id, id2, idLength)) {
222 log_err("utrans_getUnicodeID(%s) does not match the original ID\n", aescstrdup(id, idLength));
223 }
224
225 utrans_close(utrans);
226 }
227
228 uenum_reset(uenum, &errorCode);
229 if(U_FAILURE(errorCode) || count<1) {
230 log_err("uenum_reset(transliterator IDs) failed - %s\n", u_errorName(errorCode));
231 } else {
232 count2=uenum_count(uenum, &errorCode);
233 if(U_FAILURE(errorCode) || count<1) {
234 log_err("2nd uenum_count(transliterator IDs)=%d - %s\n", count2, u_errorName(errorCode));
235 } else if(count!=count2) {
236 log_err("uenum_unext(transliterator IDs) returned %d IDs but uenum_count() after uenum_reset() claims there are %d\n", count, count2);
237 }
238 }
239
240 uenum_close(uenum);
241 }
242
TestOpenInverse()243 static void TestOpenInverse(){
244 UErrorCode status=U_ZERO_ERROR;
245 UTransliterator* t1=NULL;
246 UTransliterator* inverse1=NULL;
247 enum { BUF_CAP = 128 };
248 char buf1[BUF_CAP];
249 int32_t i=0;
250
251 const char TransID[][25]={
252 "Halfwidth-Fullwidth",
253 "Fullwidth-Halfwidth",
254 "Greek-Latin" ,
255 "Latin-Greek",
256 /*"Arabic-Latin", // Removed in 2.0*/
257 /*"Latin-Arabic", // Removed in 2.0*/
258 "Katakana-Latin",
259 "Latin-Katakana",
260 /*"Hebrew-Latin", // Removed in 2.0*/
261 /*"Latin-Hebrew", // Removed in 2.0*/
262 "Cyrillic-Latin",
263 "Latin-Cyrillic",
264 "Devanagari-Latin",
265 "Latin-Devanagari",
266 "Any-Hex",
267 "Hex-Any"
268 };
269
270 for(i=0; i<sizeof(TransID)/sizeof(TransID[0]); i=i+2){
271 status = U_ZERO_ERROR;
272 t1=utrans_open(TransID[i], UTRANS_FORWARD,NULL,0,NULL, &status);
273 if(t1 == NULL || U_FAILURE(status)){
274 log_data_err("FAIL: in instantiation for id=%s -> %s (Are you missing data?)\n", TransID[i], u_errorName(status));
275 continue;
276 }
277 inverse1=utrans_openInverse(t1, &status);
278 if(U_FAILURE(status)){
279 log_err("FAIL: utrans_openInverse() failed for id=%s. Error=%s\n", TransID[i], myErrorName(status));
280 continue;
281 }
282 utrans_getID(inverse1, buf1, BUF_CAP);
283 if(strcmp(buf1, TransID[i+1]) != 0){
284 log_err("FAIL :openInverse() for %s returned %s instead of %s\n", TransID[i], buf1, TransID[i+1]);
285 }
286 utrans_close(t1);
287 utrans_close(inverse1);
288 }
289 }
290
TestClone()291 static void TestClone(){
292 UErrorCode status=U_ZERO_ERROR;
293 UTransliterator* t1=NULL;
294 UTransliterator* t2=NULL;
295 UTransliterator* t3=NULL;
296 UTransliterator* t4=NULL;
297 enum { BUF_CAP = 128 };
298 char buf1[BUF_CAP], buf2[BUF_CAP], buf3[BUF_CAP];
299
300 t1=utrans_open("Latin-Devanagari", UTRANS_FORWARD, NULL,0,NULL,&status);
301 if(U_FAILURE(status)){
302 log_data_err("FAIL: construction -> %s (Are you missing data?)\n", u_errorName(status));
303 return;
304 }
305 t2=utrans_open("Latin-Greek", UTRANS_FORWARD, NULL,0,NULL,&status);
306 if(U_FAILURE(status)){
307 log_err("FAIL: construction\n");
308 utrans_close(t1);
309 return;
310 }
311
312 t3=utrans_clone(t1, &status);
313 t4=utrans_clone(t2, &status);
314
315 utrans_getID(t1, buf1, BUF_CAP);
316 utrans_getID(t2, buf2, BUF_CAP);
317 utrans_getID(t3, buf3, BUF_CAP);
318
319 if(strcmp(buf1, buf3) != 0 ||
320 strcmp(buf1, buf2) == 0) {
321 log_err("FAIL: utrans_clone() failed\n");
322 }
323
324 utrans_getID(t4, buf3, BUF_CAP);
325
326 if(strcmp(buf2, buf3) != 0 ||
327 strcmp(buf1, buf3) == 0) {
328 log_err("FAIL: utrans_clone() failed\n");
329 }
330
331 utrans_close(t1);
332 utrans_close(t2);
333 utrans_close(t3);
334 utrans_close(t4);
335
336 }
337
TestRegisterUnregister()338 static void TestRegisterUnregister(){
339 UErrorCode status=U_ZERO_ERROR;
340 UTransliterator* t1=NULL;
341 UTransliterator* rules=NULL, *rules2;
342 UTransliterator* inverse1=NULL;
343 UChar rule[]={ 0x0061, 0x003c, 0x003e, 0x0063}; /*a<>b*/
344
345 U_STRING_DECL(ID, "TestA-TestB", 11);
346 U_STRING_INIT(ID, "TestA-TestB", 11);
347
348 /* Make sure it doesn't exist */
349 t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
350 if(t1 != NULL || U_SUCCESS(status)) {
351 log_err("FAIL: TestA-TestB already registered\n");
352 return;
353 }
354 status=U_ZERO_ERROR;
355 /* Check inverse too */
356 inverse1=utrans_open("TestA-TestB", UTRANS_REVERSE, NULL,0,NULL,&status);
357 if(inverse1 != NULL || U_SUCCESS(status)) {
358 log_err("FAIL: TestA-TestB already registered\n");
359 return;
360 }
361 status=U_ZERO_ERROR;
362 /* Create it */
363 rules=utrans_open("TestA-TestB",UTRANS_FORWARD, rule, 4, NULL, &status);
364 if(U_FAILURE(status)){
365 log_err("FAIL: utrans_openRules(a<>B) failed with error=%s\n", myErrorName(status));
366 return;
367 }
368
369 /* clone it so we can register it a second time */
370 rules2=utrans_clone(rules, &status);
371 if(U_FAILURE(status)) {
372 log_err("FAIL: utrans_clone(a<>B) failed with error=%s\n", myErrorName(status));
373 return;
374 }
375
376 status=U_ZERO_ERROR;
377 /* Register it */
378 utrans_register(rules, &status);
379 if(U_FAILURE(status)){
380 log_err("FAIL: utrans_register failed with error=%s\n", myErrorName(status));
381 return;
382 }
383 status=U_ZERO_ERROR;
384 /* Now check again -- should exist now*/
385 t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
386 if(U_FAILURE(status) || t1 == NULL){
387 log_err("FAIL: TestA-TestB not registered\n");
388 return;
389 }
390 utrans_close(t1);
391
392 /*unregister the instance*/
393 status=U_ZERO_ERROR;
394 utrans_unregister("TestA-TestB");
395 /* now Make sure it doesn't exist */
396 t1=utrans_open("TestA-TestB", UTRANS_FORWARD,NULL,0,NULL, &status);
397 if(U_SUCCESS(status) || t1 != NULL) {
398 log_err("FAIL: TestA-TestB isn't unregistered\n");
399 return;
400 }
401 utrans_close(t1);
402
403 /* now with utrans_unregisterID(const UChar *) */
404 status=U_ZERO_ERROR;
405 utrans_register(rules2, &status);
406 if(U_FAILURE(status)){
407 log_err("FAIL: 2nd utrans_register failed with error=%s\n", myErrorName(status));
408 return;
409 }
410 status=U_ZERO_ERROR;
411 /* Now check again -- should exist now*/
412 t1= utrans_open("TestA-TestB", UTRANS_FORWARD, NULL,0,NULL,&status);
413 if(U_FAILURE(status) || t1 == NULL){
414 log_err("FAIL: 2nd TestA-TestB not registered\n");
415 return;
416 }
417 utrans_close(t1);
418
419 /*unregister the instance*/
420 status=U_ZERO_ERROR;
421 utrans_unregisterID(ID, -1);
422 /* now Make sure it doesn't exist */
423 t1=utrans_openU(ID, -1, UTRANS_FORWARD,NULL,0,NULL, &status);
424 if(U_SUCCESS(status) || t1 != NULL) {
425 log_err("FAIL: 2nd TestA-TestB isn't unregistered\n");
426 return;
427 }
428
429 utrans_close(t1);
430 utrans_close(inverse1);
431 }
432
TestSimpleRules()433 static void TestSimpleRules() {
434 /* Test rules */
435 /* Example: rules 1. ab>x|y
436 * 2. yc>z
437 *
438 * []|eabcd start - no match, copy e to tranlated buffer
439 * [e]|abcd match rule 1 - copy output & adjust cursor
440 * [ex|y]cd match rule 2 - copy output & adjust cursor
441 * [exz]|d no match, copy d to transliterated buffer
442 * [exzd]| done
443 */
444 _expectRules("ab>x|y;"
445 "yc>z",
446 "eabcd", "exzd");
447
448 /* Another set of rules:
449 * 1. ab>x|yzacw
450 * 2. za>q
451 * 3. qc>r
452 * 4. cw>n
453 *
454 * []|ab Rule 1
455 * [x|yzacw] No match
456 * [xy|zacw] Rule 2
457 * [xyq|cw] Rule 4
458 * [xyqn]| Done
459 */
460 _expectRules("ab>x|yzacw;"
461 "za>q;"
462 "qc>r;"
463 "cw>n",
464 "ab", "xyqn");
465
466 /* Test categories
467 */
468 _expectRules("$dummy=" "\\uE100" ";" /* careful here with E100 */
469 "$vowel=[aeiouAEIOU];"
470 "$lu=[:Lu:];"
471 "$vowel } $lu > '!';"
472 "$vowel > '&';"
473 "'!' { $lu > '^';"
474 "$lu > '*';"
475 "a > ERROR",
476 "abcdefgABCDEFGU", "&bcd&fg!^**!^*&");
477
478 /* Test multiple passes
479 */
480 _expectRules("abc > xy;"
481 "::Null;"
482 "aba > z;",
483 "abc ababc aba", "xy abxy z");
484 }
485
TestFilter()486 static void TestFilter() {
487 UErrorCode status = U_ZERO_ERROR;
488 UChar filt[128];
489 UChar buf[128];
490 UChar exp[128];
491 char *cbuf;
492 int32_t limit;
493 const char* DATA[] = {
494 "[^c]", /* Filter out 'c' */
495 "abcde",
496 "\\u0061\\u0062c\\u0064\\u0065",
497
498 "", /* No filter */
499 "abcde",
500 "\\u0061\\u0062\\u0063\\u0064\\u0065"
501 };
502 int32_t DATA_length = sizeof(DATA) / sizeof(DATA[0]);
503 int32_t i;
504
505 UTransliterator* hex = utrans_open("Any-Hex", UTRANS_FORWARD, NULL,0,NULL,&status);
506
507 if (hex == 0 || U_FAILURE(status)) {
508 log_err("FAIL: utrans_open(Unicode-Hex) failed, error=%s\n",
509 u_errorName(status));
510 goto exit;
511 }
512
513 for (i=0; i<DATA_length; i+=3) {
514 /*u_uastrcpy(filt, DATA[i]);*/
515 u_charsToUChars(DATA[i], filt, (int32_t)strlen(DATA[i])+1);
516 utrans_setFilter(hex, filt, -1, &status);
517
518 if (U_FAILURE(status)) {
519 log_err("FAIL: utrans_setFilter() failed, error=%s\n",
520 u_errorName(status));
521 goto exit;
522 }
523
524 /*u_uastrcpy(buf, DATA[i+1]);*/
525 u_charsToUChars(DATA[i+1], buf, (int32_t)strlen(DATA[i+1])+1);
526 limit = 5;
527 utrans_transUChars(hex, buf, NULL, 128, 0, &limit, &status);
528
529 if (U_FAILURE(status)) {
530 log_err("FAIL: utrans_transUChars() failed, error=%s\n",
531 u_errorName(status));
532 goto exit;
533 }
534
535 cbuf=aescstrdup(buf, -1);
536 u_charsToUChars(DATA[i+2], exp, (int32_t)strlen(DATA[i+2])+1);
537 if (0 == u_strcmp(buf, exp)) {
538 log_verbose("Ok: %s | %s -> %s\n", DATA[i+1], DATA[i], cbuf);
539 } else {
540 log_err("FAIL: %s | %s -> %s, expected %s\n", DATA[i+1], DATA[i], cbuf, DATA[i+2]);
541 }
542 }
543
544 exit:
545 utrans_close(hex);
546 }
547
548 /**
549 * Test the UReplaceableCallback extractBetween support. We use a
550 * transliterator known to rely on this call.
551 */
TestExtractBetween()552 static void TestExtractBetween() {
553
554 UTransliterator *trans;
555 UErrorCode status = U_ZERO_ERROR;
556 UParseError parseErr;
557
558 trans = utrans_open("Lower", UTRANS_FORWARD, NULL, -1,
559 &parseErr, &status);
560
561 if (U_FAILURE(status)) {
562 log_err("FAIL: utrans_open(Lower) failed, error=%s\n",
563 u_errorName(status));
564 } else {
565 _expect(trans, "ABC", "abc");
566
567 utrans_close(trans);
568 }
569 }
570
_expectRules(const char * crules,const char * cfrom,const char * cto)571 static void _expectRules(const char* crules,
572 const char* cfrom,
573 const char* cto) {
574 /* u_uastrcpy has no capacity param for the buffer -- so just
575 * make all buffers way too big */
576 enum { CAP = 256 };
577 UChar rules[CAP];
578 UTransliterator *trans;
579 UErrorCode status = U_ZERO_ERROR;
580 UParseError parseErr;
581
582 u_uastrcpy(rules, crules);
583
584 trans = utrans_open(crules /*use rules as ID*/, UTRANS_FORWARD, rules, -1,
585 &parseErr, &status);
586 if (U_FAILURE(status)) {
587 utrans_close(trans);
588 log_data_err("FAIL: utrans_openRules(%s) failed, error=%s (Are you missing data?)\n",
589 crules, u_errorName(status));
590 return;
591 }
592
593 _expect(trans, cfrom, cto);
594
595 utrans_close(trans);
596 }
597
_expect(const UTransliterator * trans,const char * cfrom,const char * cto)598 static void _expect(const UTransliterator* trans,
599 const char* cfrom,
600 const char* cto) {
601 /* u_uastrcpy has no capacity param for the buffer -- so just
602 * make all buffers way too big */
603 enum { CAP = 256 };
604 UChar from[CAP];
605 UChar to[CAP];
606 UChar buf[CAP];
607 const UChar *ID;
608 int32_t IDLength;
609 const char *id;
610
611 UErrorCode status = U_ZERO_ERROR;
612 int32_t limit;
613 UTransPosition pos;
614 XReplaceable xrep;
615 XReplaceable *xrepPtr = &xrep;
616 UReplaceableCallbacks xrepVtable;
617
618 u_uastrcpy(from, cfrom);
619 u_uastrcpy(to, cto);
620
621 ID = utrans_getUnicodeID(trans, &IDLength);
622 id = aescstrdup(ID, IDLength);
623
624 /* utrans_transUChars() */
625 u_strcpy(buf, from);
626 limit = u_strlen(buf);
627 utrans_transUChars(trans, buf, NULL, CAP, 0, &limit, &status);
628 if (U_FAILURE(status)) {
629 log_err("FAIL: utrans_transUChars() failed, error=%s\n",
630 u_errorName(status));
631 return;
632 }
633
634 if (0 == u_strcmp(buf, to)) {
635 log_verbose("Ok: utrans_transUChars(%s) x %s -> %s\n",
636 id, cfrom, cto);
637 } else {
638 char actual[CAP];
639 u_austrcpy(actual, buf);
640 log_err("FAIL: utrans_transUChars(%s) x %s -> %s, expected %s\n",
641 id, cfrom, actual, cto);
642 }
643
644 /* utrans_transIncrementalUChars() */
645 u_strcpy(buf, from);
646 pos.start = pos.contextStart = 0;
647 pos.limit = pos.contextLimit = u_strlen(buf);
648 utrans_transIncrementalUChars(trans, buf, NULL, CAP, &pos, &status);
649 utrans_transUChars(trans, buf, NULL, CAP, pos.start, &pos.limit, &status);
650 if (U_FAILURE(status)) {
651 log_err("FAIL: utrans_transIncrementalUChars() failed, error=%s\n",
652 u_errorName(status));
653 return;
654 }
655
656 if (0 == u_strcmp(buf, to)) {
657 log_verbose("Ok: utrans_transIncrementalUChars(%s) x %s -> %s\n",
658 id, cfrom, cto);
659 } else {
660 char actual[CAP];
661 u_austrcpy(actual, buf);
662 log_err("FAIL: utrans_transIncrementalUChars(%s) x %s -> %s, expected %s\n",
663 id, cfrom, actual, cto);
664 }
665
666 /* utrans_trans() */
667 InitXReplaceableCallbacks(&xrepVtable);
668 InitXReplaceable(&xrep, cfrom);
669 limit = u_strlen(from);
670 utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, 0, &limit, &status);
671 if (U_FAILURE(status)) {
672 log_err("FAIL: utrans_trans() failed, error=%s\n",
673 u_errorName(status));
674 FreeXReplaceable(&xrep);
675 return;
676 }
677
678 if (0 == u_strcmp(xrep.text, to)) {
679 log_verbose("Ok: utrans_trans(%s) x %s -> %s\n",
680 id, cfrom, cto);
681 } else {
682 char actual[CAP];
683 u_austrcpy(actual, xrep.text);
684 log_err("FAIL: utrans_trans(%s) x %s -> %s, expected %s\n",
685 id, cfrom, actual, cto);
686 }
687 FreeXReplaceable(&xrep);
688
689 /* utrans_transIncremental() */
690 InitXReplaceable(&xrep, cfrom);
691 pos.start = pos.contextStart = 0;
692 pos.limit = pos.contextLimit = u_strlen(from);
693 utrans_transIncremental(trans, (UReplaceable*)xrepPtr, &xrepVtable, &pos, &status);
694 utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, pos.start, &pos.limit, &status);
695 if (U_FAILURE(status)) {
696 log_err("FAIL: utrans_transIncremental() failed, error=%s\n",
697 u_errorName(status));
698 FreeXReplaceable(&xrep);
699 return;
700 }
701
702 if (0 == u_strcmp(xrep.text, to)) {
703 log_verbose("Ok: utrans_transIncremental(%s) x %s -> %s\n",
704 id, cfrom, cto);
705 } else {
706 char actual[CAP];
707 u_austrcpy(actual, xrep.text);
708 log_err("FAIL: utrans_transIncremental(%s) x %s -> %s, expected %s\n",
709 id, cfrom, actual, cto);
710 }
711 FreeXReplaceable(&xrep);
712 }
713
714 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
715