]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/cintltst/ncnvfbts.c
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-66108.tar.gz
[apple/icu.git] / icuSources / test / cintltst / ncnvfbts.c
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************
4 * COPYRIGHT:
5 * Copyright (c) 1997-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 ***************************************************************************/
8 /*****************************************************************************
9 *
10 * File NCNVCBTS
11 *
12 * Modification History:
13 * Name Date Description
14 * Madhu Katragadda 06/23/2000 Tests for Conveter FallBack API and Functionality
15 ******************************************************************************
16 */
17 #include <stdio.h>
18 #include "unicode/uloc.h"
19 #include "unicode/ucnv.h"
20 #include "unicode/ucnv_err.h"
21 #include "cintltst.h"
22 #include "unicode/utypes.h"
23 #include "unicode/ustring.h"
24 #include "ncnvfbts.h"
25 #include "cmemory.h"
26 #include "cstring.h"
27
28 #if !UCONFIG_NO_LEGACY_CONVERSION
29 #define NEW_MAX_BUFFER 999
30
31
32 #define nct_min(x,y) ((x<y) ? x : y)
33
34 static int32_t gInBufferSize = 0;
35 static int32_t gOutBufferSize = 0;
36 static char gNuConvTestName[1024];
37
38 static UConverter *my_ucnv_open(const char *cnv, UErrorCode *err)
39 {
40 if(cnv && cnv[0] == '@') {
41 return ucnv_openPackage("testdata", cnv+1, err);
42 } else {
43 return ucnv_open(cnv, err);
44 }
45 }
46
47
48 static void printSeq(const unsigned char* a, int len)
49 {
50 int i=0;
51 log_verbose("{");
52 while (i<len)
53 log_verbose("0x%02x ", a[i++]);
54 log_verbose("}\n");
55 }
56
57 static void printUSeq(const UChar* a, int len)
58 {
59 int i=0;
60 log_verbose("{U+");
61 while (i<len)
62 log_verbose("0x%04x ", a[i++]);
63 log_verbose("}\n");
64 }
65
66 static void printSeqErr(const unsigned char* a, int len)
67 {
68 int i=0;
69 fprintf(stderr, "{");
70 while (i<len)
71 fprintf(stderr, "0x%02x ", a[i++]);
72 fprintf(stderr, "}\n");
73 }
74
75 static void printUSeqErr(const UChar* a, int len)
76 {
77 int i=0;
78 fprintf(stderr, "{U+");
79 while (i<len)
80 fprintf(stderr, "0x%04x ", a[i++]);
81 fprintf(stderr,"}\n");
82 }
83
84 static void TestConverterFallBack(void)
85 {
86 TestConvertFallBackWithBufferSizes(10,10);
87 TestConvertFallBackWithBufferSizes(2,3);
88 TestConvertFallBackWithBufferSizes(3,2);
89 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,1);
90 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,2);
91 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,3);
92 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,4);
93 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,5);
94 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,6);
95 TestConvertFallBackWithBufferSizes(1,NEW_MAX_BUFFER);
96 TestConvertFallBackWithBufferSizes(2,NEW_MAX_BUFFER);
97 TestConvertFallBackWithBufferSizes(3,NEW_MAX_BUFFER);
98 TestConvertFallBackWithBufferSizes(4,NEW_MAX_BUFFER);
99 TestConvertFallBackWithBufferSizes(5,NEW_MAX_BUFFER);
100 TestConvertFallBackWithBufferSizes(NEW_MAX_BUFFER,NEW_MAX_BUFFER);
101
102 }
103
104
105 void addTestConverterFallBack(TestNode** root);
106
107 void addTestConverterFallBack(TestNode** root)
108 {
109 #if !UCONFIG_NO_FILE_IO
110 addTest(root, &TestConverterFallBack, "tsconv/ncnvfbts/TestConverterFallBack");
111 #endif
112
113 }
114
115
116 /* Note that this test already makes use of statics, so it's not really
117 multithread safe.
118 This convenience function lets us make the error messages actually useful.
119 */
120
121 static void setNuConvTestName(const char *codepage, const char *direction)
122 {
123 sprintf(gNuConvTestName, "[Testing %s %s Unicode, InputBufSiz=%d, OutputBufSiz=%d]",
124 codepage,
125 direction,
126 (int)gInBufferSize,
127 (int)gOutBufferSize);
128 }
129
130
131 static UBool testConvertFromUnicode(const UChar *source, int sourceLen, const uint8_t *expect, int expectLen,
132 const char *codepage, UBool fallback, const int32_t *expectOffsets)
133 {
134
135
136 UErrorCode status = U_ZERO_ERROR;
137 UConverter *conv = 0;
138 char junkout[NEW_MAX_BUFFER]; /* FIX */
139 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
140 const UChar *src;
141 char *end;
142 char *targ;
143 int32_t *offs;
144 int i;
145 int32_t realBufferSize;
146 char *realBufferEnd;
147 const UChar *realSourceEnd;
148 const UChar *sourceLimit;
149 UBool checkOffsets = TRUE;
150 UBool doFlush;
151 UBool action=FALSE;
152 char *p;
153
154
155 for(i=0;i<NEW_MAX_BUFFER;i++)
156 junkout[i] = (char)0xF0;
157 for(i=0;i<NEW_MAX_BUFFER;i++)
158 junokout[i] = 0xFF;
159 setNuConvTestName(codepage, "FROM");
160
161 log_verbose("\nTesting========= %s FROM \n inputbuffer= %d outputbuffer= %d\n", codepage, gInBufferSize,
162 gOutBufferSize);
163
164 conv = my_ucnv_open(codepage, &status);
165 if(U_FAILURE(status))
166 {
167 log_data_err("Couldn't open converter %s\n",codepage);
168 return TRUE;
169 }
170
171 log_verbose("Converter opened..\n");
172 /*----setting the callback routine----*/
173 ucnv_setFallback (conv, fallback);
174 action = ucnv_usesFallback(conv);
175 if(action != fallback){
176 log_err("FAIL: Error is setting fallback. Errocode=%s\n", myErrorName(status));
177 }
178 /*------------------------*/
179 src = source;
180 targ = junkout;
181 offs = junokout;
182
183 realBufferSize = UPRV_LENGTHOF(junkout);
184 realBufferEnd = junkout + realBufferSize;
185 realSourceEnd = source + sourceLen;
186
187 if ( gOutBufferSize != realBufferSize )
188 checkOffsets = FALSE;
189
190 if( gInBufferSize != NEW_MAX_BUFFER )
191 checkOffsets = FALSE;
192
193 do
194 {
195 end = nct_min(targ + gOutBufferSize, realBufferEnd);
196 sourceLimit = nct_min(src + gInBufferSize, realSourceEnd);
197
198 doFlush = (UBool)(sourceLimit == realSourceEnd);
199
200 if(targ == realBufferEnd)
201 {
202 log_err("Error, overflowed the real buffer while about to call fromUnicode! targ=%08lx %s", targ, gNuConvTestName);
203 return FALSE;
204 }
205 log_verbose("calling fromUnicode @ SOURCE:%08lx to %08lx TARGET: %08lx to %08lx, flush=%s\n", src,sourceLimit, targ,end, doFlush?"TRUE":"FALSE");
206
207
208 status = U_ZERO_ERROR;
209
210 ucnv_fromUnicode (conv,
211 (char **)&targ,
212 (const char *)end,
213 &src,
214 sourceLimit,
215 checkOffsets ? offs : NULL,
216 doFlush, /* flush if we're at the end of the input data */
217 &status);
218
219 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (sourceLimit < realSourceEnd) );
220
221 if(U_FAILURE(status))
222 {
223 log_err("Problem doing toUnicode, errcode %d %s\n", myErrorName(status), gNuConvTestName);
224 return FALSE;
225 }
226
227 log_verbose("\nConversion done [%d uchars in -> %d chars out]. \nResult :",
228 sourceLen, targ-junkout);
229 if(getTestOption(VERBOSITY_OPTION))
230 {
231 char junk[9999];
232 char offset_str[9999];
233
234 junk[0] = 0;
235 offset_str[0] = 0;
236 for(p = junkout;p<targ;p++)
237 {
238 sprintf(junk + uprv_strlen(junk), "0x%02x, ", (0xFF) & (unsigned int)*p);
239 sprintf(offset_str + strlen(offset_str), "0x%02x, ", (0xFF) & (unsigned int)junokout[p-junkout]);
240 }
241
242 log_verbose(junk);
243 printSeq((const unsigned char*)expect, expectLen);
244 if ( checkOffsets )
245 {
246 log_verbose("\nOffsets:");
247 log_verbose(offset_str);
248 }
249 log_verbose("\n");
250 }
251 ucnv_close(conv);
252
253
254 if(expectLen != targ-junkout)
255 {
256 log_err("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
257 log_verbose("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
258 printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
259 printSeqErr((const unsigned char*)expect, expectLen);
260 return FALSE;
261 }
262
263 if (checkOffsets && (expectOffsets != 0) )
264 {
265 log_verbose("\ncomparing %d offsets..\n", targ-junkout);
266 if(uprv_memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t) )){
267 log_err("\ndid not get the expected offsets while %s \n", gNuConvTestName);
268 log_err("Got : ");
269 printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
270 for(p=junkout;p<targ;p++)
271 log_err("%d, ", junokout[p-junkout]);
272 log_err("\nExpected: ");
273 for(i=0; i<(targ-junkout); i++)
274 log_err("%d,", expectOffsets[i]);
275 }
276 }
277
278 log_verbose("\n\ncomparing..\n");
279 if(!memcmp(junkout, expect, expectLen))
280 {
281 log_verbose("Matches!\n");
282 return TRUE;
283 }
284 else
285 {
286 log_err("String does not match. %s\n", gNuConvTestName);
287 log_verbose("String does not match. %s\n", gNuConvTestName);
288 printSeqErr((const unsigned char*)junkout, expectLen);
289 printSeqErr((const unsigned char*)expect, expectLen);
290 return FALSE;
291 }
292 }
293
294 static UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen,
295 const char *codepage, UBool fallback, const int32_t *expectOffsets)
296 {
297 UErrorCode status = U_ZERO_ERROR;
298 UConverter *conv = 0;
299 UChar junkout[NEW_MAX_BUFFER]; /* FIX */
300 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
301 const char *src;
302 const char *realSourceEnd;
303 const char *srcLimit;
304 UChar *targ;
305 UChar *end;
306 int32_t *offs;
307 int i;
308 UBool checkOffsets = TRUE;
309 char junk[9999];
310 char offset_str[9999];
311 UChar *p;
312 UBool action;
313
314 int32_t realBufferSize;
315 UChar *realBufferEnd;
316
317
318 for(i=0;i<NEW_MAX_BUFFER;i++)
319 junkout[i] = 0xFFFE;
320
321 for(i=0;i<NEW_MAX_BUFFER;i++)
322 junokout[i] = -1;
323
324 setNuConvTestName(codepage, "TO");
325
326 log_verbose("\n========= %s\n", gNuConvTestName);
327
328 conv = my_ucnv_open(codepage, &status);
329 if(U_FAILURE(status))
330 {
331 log_data_err("Couldn't open converter %s\n",gNuConvTestName);
332 return TRUE; /* because it has been logged */
333 }
334
335 log_verbose("Converter opened..\n");
336
337 src = (const char *)source;
338 targ = junkout;
339 offs = junokout;
340
341 realBufferSize = UPRV_LENGTHOF(junkout);
342 realBufferEnd = junkout + realBufferSize;
343 realSourceEnd = src + sourcelen;
344 /*----setting the fallback routine----*/
345 ucnv_setFallback (conv, fallback);
346 action = ucnv_usesFallback(conv);
347 if(action != fallback){
348 log_err("FAIL: Error is setting fallback. Errocode=%s\n", myErrorName(status));
349 }
350 /*-------------------------------------*/
351 if ( gOutBufferSize != realBufferSize )
352 checkOffsets = FALSE;
353
354 if( gInBufferSize != NEW_MAX_BUFFER )
355 checkOffsets = FALSE;
356
357 do
358 {
359 end = nct_min( targ + gOutBufferSize, realBufferEnd);
360 srcLimit = nct_min(realSourceEnd, src + gInBufferSize);
361
362 if(targ == realBufferEnd)
363 {
364 log_err("Error, the end would overflow the real output buffer while about to call toUnicode! tarjey=%08lx %s",targ,gNuConvTestName);
365 return FALSE;
366 }
367 log_verbose("calling toUnicode @ %08lx to %08lx\n", targ,end);
368
369
370
371 status = U_ZERO_ERROR;
372
373 ucnv_toUnicode (conv,
374 &targ,
375 end,
376 (const char **)&src,
377 (const char *)srcLimit,
378 checkOffsets ? offs : NULL,
379 (UBool)(srcLimit == realSourceEnd), /* flush if we're at the end of hte source data */
380 &status);
381 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (srcLimit < realSourceEnd) ); /* while we just need another buffer */
382
383
384 if(U_FAILURE(status))
385 {
386 log_err("Problem doing toUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
387 return FALSE;
388 }
389
390 log_verbose("\nConversion done. %d bytes -> %d chars.\nResult :",
391 sourcelen, targ-junkout);
392 if(getTestOption(VERBOSITY_OPTION))
393 {
394
395 junk[0] = 0;
396 offset_str[0] = 0;
397
398 for(p = junkout;p<targ;p++)
399 {
400 sprintf(junk + strlen(junk), "0x%04x, ", (0xFFFF) & (unsigned int)*p);
401 sprintf(offset_str + strlen(offset_str), "0x%04x, ", (0xFFFF) & (unsigned int)junokout[p-junkout]);
402 }
403
404 log_verbose(junk);
405 printUSeq(expect, expectlen);
406 if ( checkOffsets )
407 {
408 log_verbose("\nOffsets:");
409 log_verbose(offset_str);
410 }
411 log_verbose("\n");
412 }
413 ucnv_close(conv);
414
415 log_verbose("comparing %d uchars (%d bytes)..\n",expectlen,expectlen*2);
416
417 if (checkOffsets && (expectOffsets != 0))
418 {
419 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t)))
420 {
421 log_err("\n\ndid not get the expected offsets while %s \n", gNuConvTestName);
422 log_err("\nGot : ");
423 for(p=junkout;p<targ;p++)
424 log_err("%d, ", junokout[p-junkout]);
425 log_err("\nExpected: ");
426 for(i=0; i<(targ-junkout); i++)
427 log_err("%d,", expectOffsets[i]);
428 log_err("");
429 for(i=0; i<(targ-junkout); i++)
430 log_err("0x%04X,", junkout[i]);
431 log_err("");
432 for(i=0; i<(src-(const char *)source); i++)
433 log_err("0x%04X,", (unsigned char)source[i]);
434 }
435 }
436
437 if(!memcmp(junkout, expect, expectlen*2))
438 {
439 log_verbose("Matches!\n");
440 return TRUE;
441 }
442 else
443 {
444 log_err("String does not match. %s\n", gNuConvTestName);
445 log_verbose("String does not match. %s\n", gNuConvTestName);
446 printUSeqErr(junkout, expectlen);
447 printf("\n");
448 printUSeqErr(expect, expectlen);
449 return FALSE;
450 }
451 }
452
453
454
455 static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize )
456 {
457
458 static const UChar SBCSText[] =
459 { 0x0021, 0xFF01, 0x0022, 0xFF02, 0x0023, 0xFF03, 0x003A, 0xFF1A, 0x003B, 0xFF1B, 0x003C, 0xFF1C };
460 /* 21, ?, 22, ?, 23, ?, 3a, ?, 3b, ?, 3c, ? SBCS*/
461 static const uint8_t expectedNative[] =
462 { 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x3a, 0x3a, 0x3b, 0x3b, 0x3c, 0x3c};
463 static const UChar retrievedSBCSText[]=
464 { 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x003A, 0x003A, 0x003B, 0x003B, 0x003C, 0x003C };
465 static const int32_t toNativeOffs [] =
466 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b};
467 static const int32_t fromNativeoffs [] =
468 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
469
470
471 /* 1363 isn't DBCS, but it has the DBCS section */
472 static const UChar DBCSText[] =
473 { 0x00a1, 0x00ad, 0x2010, 0x00b7, 0x30fb};
474 static const uint8_t expectedIBM1363_DBCS[] =
475 { 0xa2, 0xae, 0xa1 ,0xa9, 0xa1, 0xa9,0xa1 ,0xa4, 0xa1, 0xa4};
476 static const UChar retrievedDBCSText[]=
477 { 0x00a1, 0x2010, 0x2010, 0x30fb, 0x30fb };
478 static const int32_t toIBM1363Offs_DBCS[] =
479 { 0x00, 0x00, 0x01,0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04};
480 static const int32_t fromIBM1363offs_DBCS[] =
481 { 0, 2, 4, 6, 8};
482
483
484 static const UChar MBCSText[] =
485 { 0x0001, 0x263a, 0x2013, 0x2014, 0x263b, 0x0002};
486 static const uint8_t expectedIBM950[] =
487 { 0x01, 0x01, 0xa1, 0x56, 0xa1, 0x56, 0x02, 0x02};
488 static const UChar retrievedMBCSText[]=
489 { 0x0001, 0x0001, 0x2014, 0x2014, 0x0002, 0x0002};
490 static const int32_t toIBM950Offs [] =
491 { 0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05};
492 static const int32_t fromIBM950offs [] =
493 { 0, 1, 2, 4, 6, 7};
494
495 static const UChar MBCSText1363[] =
496 { 0x0005,
497 0xffe8,
498 0x0007,
499 0x2022,
500 0x005c,
501 0x00b7,
502 0x3016,
503 0x30fb,
504 0x9a36};
505 static const uint8_t expectedIBM1363[] =
506 { 0x05,
507 0x05,
508 0x07,
509 0x07,
510 0x7f,
511 0xa1, 0xa4,
512 0xa1, 0xe0,
513 0xa1, 0xa4,
514 0xf5, 0xe2};
515 static const UChar retrievedMBCSText1363[]=
516 { 0x0005, 0x0005, 0x0007, 0x0007, 0x001a, 0x30fb, 0x25a1, 0x30fb, 0x9a36};
517 static const int32_t toIBM1363Offs [] =
518 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08};
519 static const int32_t fromIBM1363offs [] =
520 { 0, 1, 2, 3, 4, 5, 7, 9, 11};
521
522
523
524 static const char* nativeCodePage[]={
525 /*NLCS Mapping*/
526 "ibm-437",
527 "ibm-850",
528 "ibm-878",
529 "ibm-923",
530 "ibm-1051",
531 "ibm-1089",
532 "ibm-1250",
533 "ibm-1251",
534 "ibm-1253",
535 "ibm-1254",
536 "ibm-1255",
537 "ibm-1256",
538 "ibm-1257",
539 "ibm-1258",
540 "ibm-1276"
541 };
542
543 int32_t i=0;
544 gInBufferSize = insize;
545 gOutBufferSize = outsize;
546
547 for(i=0; i<UPRV_LENGTHOF(nativeCodePage); i++){
548 log_verbose("Testing %s\n", nativeCodePage[i]);
549 if(!testConvertFromUnicode(SBCSText, UPRV_LENGTHOF(SBCSText),
550 expectedNative, sizeof(expectedNative), nativeCodePage[i], TRUE, toNativeOffs ))
551 log_err("u-> %s(SBCS) with FallBack did not match.\n", nativeCodePage[i]);
552
553 if(!testConvertToUnicode(expectedNative, sizeof(expectedNative),
554 retrievedSBCSText, UPRV_LENGTHOF(retrievedSBCSText), nativeCodePage[i], TRUE, fromNativeoffs ))
555 log_err("%s->u(SBCS) with Fallback did not match.\n", nativeCodePage[i]);
556 }
557
558 /*DBCS*/
559 if(!testConvertFromUnicode(DBCSText, UPRV_LENGTHOF(DBCSText),
560 expectedIBM1363_DBCS, sizeof(expectedIBM1363_DBCS), "ibm-1363", TRUE, toIBM1363Offs_DBCS ))
561 log_err("u-> ibm-1363(DBCS portion) with FallBack did not match.\n");
562
563 if(!testConvertToUnicode(expectedIBM1363_DBCS, sizeof(expectedIBM1363_DBCS),
564 retrievedDBCSText, UPRV_LENGTHOF(retrievedDBCSText),"ibm-1363", TRUE, fromIBM1363offs_DBCS ))
565 log_err("ibm-1363->u(DBCS portion) with Fallback did not match.\n");
566
567
568 /*MBCS*/
569 if(!testConvertFromUnicode(MBCSText, UPRV_LENGTHOF(MBCSText),
570 expectedIBM950, sizeof(expectedIBM950), "ibm-950", TRUE, toIBM950Offs ))
571 log_err("u-> ibm-950(MBCS) with FallBack did not match.\n");
572
573 if(!testConvertToUnicode(expectedIBM950, sizeof(expectedIBM950),
574 retrievedMBCSText, UPRV_LENGTHOF(retrievedMBCSText),"ibm-950", TRUE, fromIBM950offs ))
575 log_err("ibm-950->u(MBCS) with Fallback did not match.\n");
576
577 /*commented untill data table is available*/
578 log_verbose("toUnicode fallback with fallback data for MBCS\n");
579 {
580 const uint8_t IBM950input[] = {
581 0xf4, 0x87, 0xa4, 0x4a, 0xf4, 0x88, 0xa4, 0x4b,
582 0xf9, 0x92, 0xdc, 0xb0, };
583 UChar expectedUnicodeText[]= { 0x5165, 0x5165, 0x516b, 0x516b, 0x9ef9, 0x9ef9};
584 int32_t fromIBM950inputOffs [] = { 0, 2, 4, 6, 8, 10};
585 /* for testing reverse fallback behavior */
586 UChar expectedFallbackFalse[]= { 0x5165, 0x5165, 0x516b, 0x516b, 0x9ef9, 0x9ef9};
587
588 if(!testConvertToUnicode(IBM950input, sizeof(IBM950input),
589 expectedUnicodeText, UPRV_LENGTHOF(expectedUnicodeText),"ibm-950", TRUE, fromIBM950inputOffs ))
590 log_err("ibm-950->u(MBCS) with Fallback did not match.\n");
591 if(!testConvertToUnicode(IBM950input, sizeof(IBM950input),
592 expectedFallbackFalse, UPRV_LENGTHOF(expectedFallbackFalse),"ibm-950", FALSE, fromIBM950inputOffs ))
593 log_err("ibm-950->u(MBCS) with Fallback did not match.\n");
594
595 }
596 log_verbose("toUnicode fallback with fallback data for euc-tw\n");
597 {
598 const uint8_t euc_tw_input[] = {
599 0xA7, 0xCC, 0x8E, 0xA2, 0xA1, 0xAB,
600 0xA8, 0xC7, 0xC8, 0xDE,
601 0xA8, 0xCD, 0x8E, 0xA2, 0xA2, 0xEA,};
602 UChar expectedUnicodeText[]= { 0x5C6E, 0x5C6E, 0x81FC, 0x81FC, 0x8278, 0x8278};
603 int32_t from_euc_tw_offs [] = { 0, 2, 6, 8, 10, 12};
604 /* for testing reverse fallback behavior */
605 UChar expectedFallbackFalse[]= { 0x5C6E, 0x5C6E, 0x81FC, 0x81FC, 0x8278, 0x8278};
606
607 if(!testConvertToUnicode(euc_tw_input, sizeof(euc_tw_input),
608 expectedUnicodeText, UPRV_LENGTHOF(expectedUnicodeText),"euc-tw", TRUE, from_euc_tw_offs ))
609 log_err("from euc-tw->u with Fallback did not match.\n");
610
611 if(!testConvertToUnicode(euc_tw_input, sizeof(euc_tw_input),
612 expectedFallbackFalse, UPRV_LENGTHOF(expectedFallbackFalse),"euc-tw", FALSE, from_euc_tw_offs ))
613 log_err("from euc-tw->u with Fallback false did not match.\n");
614
615
616 }
617 log_verbose("fromUnicode to euc-tw with fallback data euc-tw\n");
618 {
619 UChar inputText[]= { 0x0001, 0x008e, 0x203e, 0x2223, 0xff5c, 0x5296,
620 0x5C6E, 0x5C6E, 0x81FC, 0x81FC, 0x8278, 0x8278, 0xEDEC};
621 const uint8_t expected_euc_tw[] = {
622 0x01, 0x1a, 0xa2, 0xa3,
623 0xa2, 0xde, 0xa2, 0xde,
624 0x8e, 0xa2, 0xe5, 0xb9,
625 0x8e, 0xa2, 0xa1, 0xab, 0x8e, 0xa2, 0xa1, 0xab,
626 0xc8, 0xde, 0xc8, 0xde,
627 0x8e, 0xa2, 0xa2, 0xea, 0x8e, 0xa2, 0xa2, 0xea,
628 0x8e, 0xac, 0xc6, 0xf7};
629 int32_t to_euc_tw_offs [] = { 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6,
630 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12};
631
632 if(!testConvertFromUnicode(inputText, UPRV_LENGTHOF(inputText),
633 expected_euc_tw, sizeof(expected_euc_tw), "euc-tw", TRUE, to_euc_tw_offs ))
634 log_err("u-> euc-tw with FallBack did not match.\n");
635
636 }
637
638 /*MBCS 1363*/
639 if(!testConvertFromUnicode(MBCSText1363, UPRV_LENGTHOF(MBCSText1363),
640 expectedIBM1363, sizeof(expectedIBM1363), "ibm-1363", TRUE, toIBM1363Offs ))
641 log_err("u-> ibm-1363(MBCS) with FallBack did not match.\n");
642
643 if(!testConvertToUnicode(expectedIBM1363, sizeof(expectedIBM1363),
644 retrievedMBCSText1363, UPRV_LENGTHOF(retrievedMBCSText1363),"ibm-1363", TRUE, fromIBM1363offs ))
645 log_err("ibm-1363->u(MBCS) with Fallback did not match.\n");
646
647
648 /*some more test to increase the code coverage in MBCS. Create an test converter from test1.ucm
649 which is test file for MBCS conversion with single-byte codepage data.*/
650 {
651
652 /* MBCS with single byte codepage data test1.ucm*/
653 const UChar unicodeInput[] = { 0x20ac, 0x0005, 0x0006, 0xdbc4, 0xde34, 0xdbba, 0xdfcd, 0x0003};
654 const uint8_t expectedtest1[] = { 0x00, 0x05, 0xff, 0x07, 0x08, 0xff,};
655 int32_t totest1Offs[] = { 0, 1, 2, 3, 5, 7};
656
657 const uint8_t test1input[] = { 0x00, 0x05, 0x06, 0x07, 0x08, 0x09};
658 const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0xdbc4, 0xde34, 0xfffd, 0xfffd, 0xfffe};
659 int32_t fromtest1Offs[] = { 0, 1, 2, 3, 3, 4,5};
660
661 /*from Unicode*/
662 if(!testConvertFromUnicode(unicodeInput, UPRV_LENGTHOF(unicodeInput),
663 expectedtest1, sizeof(expectedtest1), "@test1", TRUE, totest1Offs ))
664 log_err("u-> test1(MBCS conversion with single-byte) did not match.\n");
665
666 /*to Unicode*/
667 if(!testConvertToUnicode(test1input, sizeof(test1input),
668 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test1", TRUE, fromtest1Offs ))
669 log_err("test1(MBCS conversion with single-byte) -> u did not match.\n");
670
671 }
672
673 /*some more test to increase the code coverage in MBCS. Create an test converter from test3.ucm
674 which is test file for MBCS conversion with three-byte codepage data.*/
675 {
676
677 /* MBCS with three byte codepage data test3.ucm*/
678 const UChar unicodeInput[] = { 0x20ac, 0x0005, 0x0006, 0xdbc4, 0xde34, 0xdbba, 0xdfcd, 0x000b, 0xd84d, 0xdc56, 0x000e, 0x0003, };
679 const uint8_t expectedtest3[] = { 0x00, 0x05, 0xff, 0x07, 0xff, 0x01, 0x02, 0x0b, 0x01, 0x02, 0x0a, 0xff, 0xff,};
680 int32_t totest3Offs[] = { 0, 1, 2, 3, 5, 7, 7, 7, 8, 8, 8, 10, 11};
681
682 const uint8_t test3input[] = { 0x00, 0x05, 0x06, 0x01, 0x02, 0x0b, 0x07, 0x01, 0x02, 0x0a,
683 0x01, 0x02, 0x0e, 0x01, 0x02, 0x0d, 0x03, 0x01, 0x02, 0x0f,};
684 const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56,
685 0x000e, 0xd891, 0xdd67, 0xfffd, 0xfffd };
686 int32_t fromtest3Offs[] = { 0, 1, 2, 3, 6, 6, 7, 7, 10, 13, 13, 16, 17};
687
688 /*from Unicode*/
689 if(!testConvertFromUnicode(unicodeInput, UPRV_LENGTHOF(unicodeInput),
690 expectedtest3, sizeof(expectedtest3), "@test3", TRUE, totest3Offs ))
691 log_err("u-> test3(MBCS conversion with three-byte) did not match.\n");
692
693 /*to Unicode*/
694 if(!testConvertToUnicode(test3input, sizeof(test3input),
695 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test3", TRUE, fromtest3Offs ))
696 log_err("test3(MBCS conversion with three-byte) -> u did not match.\n");
697
698 }
699
700 /*some more test to increase the code coverage in MBCS. Create an test converter from test4.ucm
701 which is test file for MBCS conversion with four-byte codepage data.*/
702 {
703
704 /* MBCS with three byte codepage data test4.ucm*/
705 const UChar unicodeInput[] =
706 { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xdbba, 0xdfcd,
707 0xd84d, 0xdc56, 0x000e, 0xd891, 0xdd67, 0x000f};
708 const uint8_t expectedtest4[] =
709 { 0x00, 0x05, 0xff, 0x01, 0x02, 0x03, 0x0b, 0x07, 0xff,
710 0x01, 0x02, 0x03, 0x0a, 0xff, 0xff, 0xff};
711 int32_t totest4Offs[] =
712 { 0, 1, 2, 3, 3, 3, 3, 4, 6, 8, 8, 8, 8, 10, 11, 13};
713
714 const uint8_t test4input[] =
715 { 0x00, 0x05, 0x06, 0x01, 0x02, 0x03, 0x0b, 0x07, 0x08,
716 0x01, 0x02, 0x03, 0x0a, 0x01, 0x02, 0x03, 0x0e, 0x01, 0x02, 0x03, 0x0d, 0x03, 0x01, 0x02, 0x03, 0x0c,};
717 const UChar expectedUnicode[] =
718 { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xdbba, 0xdfcd,
719 0xd84d, 0xdc56, 0x000e, 0xd891, 0xdd67, 0x1a, 0xfffd};
720 int32_t fromtest4Offs[] =
721 { 0, 1, 2, 3, 7, 7, 8, 8, 9, 9, 13, 17, 17, 21, 22,};
722
723 /*from Unicode*/
724 if(!testConvertFromUnicode(unicodeInput, UPRV_LENGTHOF(unicodeInput),
725 expectedtest4, sizeof(expectedtest4), "@test4", TRUE, totest4Offs ))
726 log_err("u-> test4(MBCS conversion with four-byte) did not match.\n");
727
728 /*to Unicode*/
729 if(!testConvertToUnicode(test4input, sizeof(test4input),
730 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test4", TRUE, fromtest4Offs ))
731 log_err("test4(MBCS conversion with four-byte) -> u did not match.\n");
732
733 }
734 /* Test for jitterbug 509 EBCDIC_STATEFUL Converters*/
735 {
736 const UChar unicodeInput[] = {0x00AF, 0x2013, 0x2223, 0x004C, 0x5F5D, 0xFF5E };
737 const uint8_t expectedtest1[] = {0x0E,0x42,0xA1, 0x44,0x4A, 0x42,0x4F, 0x0F,0xD3, 0x0E,0x65,0x60, 0x43,0xA1,0x0f };
738 int32_t totest1Offs[] = {0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5 };
739 const uint8_t test1input[] = {0x0E,0x42,0xA1, 0x44,0x4A, 0x42,0x4F, 0x0F,0xD3, 0x0E,0x65,0x60, 0x43,0xA1 };
740 const UChar expectedUnicode[] = {0x203e, 0x2014, 0xff5c, 0x004c, 0x5f5e, 0x223c };
741 int32_t fromtest1Offs[] = {1, 3, 5, 8, 10, 12 };
742 /*from Unicode*/
743 if(!testConvertFromUnicode(unicodeInput, UPRV_LENGTHOF(unicodeInput),
744 expectedtest1, sizeof(expectedtest1), "ibm-1371", TRUE, totest1Offs ))
745 log_err("u-> ibm-1371(MBCS conversion with single-byte) did not match.,\n");
746 /*to Unicode*/
747 if(!testConvertToUnicode(test1input, sizeof(test1input),
748 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "ibm-1371", TRUE, fromtest1Offs ))
749 log_err("ibm-1371(MBCS conversion with single-byte) -> u did not match.,\n");
750 }
751
752 }
753 #endif
mirror of ICU