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