]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/cintltst/nucnvtst.c
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-59173.0.1.tar.gz
[apple/icu.git] / icuSources / test / cintltst / nucnvtst.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 nucnvtst.c
11 *
12 * Modification History:
13 * Name Description
14 * Steven R. Loomis 7/8/1999 Adding input buffer test
15 ********************************************************************************
16 */
17 #include <stdio.h>
18 #include "cstring.h"
19 #include "unicode/uloc.h"
20 #include "unicode/ucnv.h"
21 #include "unicode/ucnv_err.h"
22 #include "unicode/ucnv_cb.h"
23 #include "cintltst.h"
24 #include "unicode/utypes.h"
25 #include "unicode/ustring.h"
26 #include "unicode/ucol.h"
27 #include "unicode/utf16.h"
28 #include "cmemory.h"
29 #include "nucnvtst.h"
30
31 static void TestNextUChar(UConverter* cnv, const char* source, const char* limit, const int32_t results[], const char* message);
32 static void TestNextUCharError(UConverter* cnv, const char* source, const char* limit, UErrorCode expected, const char* message);
33 #if !UCONFIG_NO_COLLATION
34 static void TestJitterbug981(void);
35 #endif
36 #if !UCONFIG_NO_LEGACY_CONVERSION
37 static void TestJitterbug1293(void);
38 #endif
39 static void TestNewConvertWithBufferSizes(int32_t osize, int32_t isize) ;
40 static void TestConverterTypesAndStarters(void);
41 static void TestAmbiguous(void);
42 static void TestSignatureDetection(void);
43 static void TestUTF7(void);
44 static void TestIMAP(void);
45 static void TestUTF8(void);
46 static void TestCESU8(void);
47 static void TestUTF16(void);
48 static void TestUTF16BE(void);
49 static void TestUTF16LE(void);
50 static void TestUTF32(void);
51 static void TestUTF32BE(void);
52 static void TestUTF32LE(void);
53 static void TestLATIN1(void);
54
55 #if !UCONFIG_NO_LEGACY_CONVERSION
56 static void TestSBCS(void);
57 static void TestDBCS(void);
58 static void TestMBCS(void);
59 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_NO_FILE_IO
60 static void TestICCRunout(void);
61 #endif
62
63 #ifdef U_ENABLE_GENERIC_ISO_2022
64 static void TestISO_2022(void);
65 #endif
66
67 static void TestISO_2022_JP(void);
68 static void TestISO_2022_JP_1(void);
69 static void TestISO_2022_JP_2(void);
70 static void TestISO_2022_KR(void);
71 static void TestISO_2022_KR_1(void);
72 static void TestISO_2022_CN(void);
73 #if 0
74 /*
75 * ICU 4.4 (ticket #7314) removes mappings for CNS 11643 planes 3..7
76 */
77 static void TestISO_2022_CN_EXT(void);
78 #endif
79 static void TestJIS(void);
80 static void TestHZ(void);
81 #endif
82
83 static void TestSCSU(void);
84
85 #if !UCONFIG_NO_LEGACY_CONVERSION
86 static void TestEBCDIC_STATEFUL(void);
87 static void TestGB18030(void);
88 static void TestLMBCS(void);
89 static void TestJitterbug255(void);
90 static void TestEBCDICUS4XML(void);
91 #if 0
92 /*
93 * ICU 4.4 (ticket #7314) removes mappings for CNS 11643 planes 3..7
94 */
95 static void TestJitterbug915(void);
96 #endif
97 static void TestISCII(void);
98
99 static void TestCoverageMBCS(void);
100 static void TestJitterbug2346(void);
101 static void TestJitterbug2411(void);
102 static void TestJB5275(void);
103 static void TestJB5275_1(void);
104 static void TestJitterbug6175(void);
105
106 static void TestIsFixedWidth(void);
107 #endif
108
109 static void TestInBufSizes(void);
110
111 static void TestRoundTrippingAllUTF(void);
112 static void TestConv(const uint16_t in[],
113 int len,
114 const char* conv,
115 const char* lang,
116 char byteArr[],
117 int byteArrLen);
118
119 /* open a converter, using test data if it begins with '@' */
120 static UConverter *my_ucnv_open(const char *cnv, UErrorCode *err);
121
122
123 #define NEW_MAX_BUFFER 999
124
125 static int32_t gInBufferSize = NEW_MAX_BUFFER;
126 static int32_t gOutBufferSize = NEW_MAX_BUFFER;
127 static char gNuConvTestName[1024];
128
129 #define nct_min(x,y) ((x<y) ? x : y)
130
131 static UConverter *my_ucnv_open(const char *cnv, UErrorCode *err)
132 {
133 if(cnv && cnv[0] == '@') {
134 return ucnv_openPackage(loadTestData(err), cnv+1, err);
135 } else {
136 return ucnv_open(cnv, err);
137 }
138 }
139
140 static void printSeq(const unsigned char* a, int len)
141 {
142 int i=0;
143 log_verbose("{");
144 while (i<len)
145 log_verbose("0x%02x ", a[i++]);
146 log_verbose("}\n");
147 }
148
149 static void printUSeq(const UChar* a, int len)
150 {
151 int i=0;
152 log_verbose("{U+");
153 while (i<len) log_verbose("0x%04x ", a[i++]);
154 log_verbose("}\n");
155 }
156
157 static void printSeqErr(const unsigned char* a, int len)
158 {
159 int i=0;
160 fprintf(stderr, "{");
161 while (i<len)
162 fprintf(stderr, "0x%02x ", a[i++]);
163 fprintf(stderr, "}\n");
164 }
165
166 static void printUSeqErr(const UChar* a, int len)
167 {
168 int i=0;
169 fprintf(stderr, "{U+");
170 while (i<len)
171 fprintf(stderr, "0x%04x ", a[i++]);
172 fprintf(stderr,"}\n");
173 }
174
175 static void
176 TestNextUChar(UConverter* cnv, const char* source, const char* limit, const int32_t results[], const char* message)
177 {
178 const char* s0;
179 const char* s=(char*)source;
180 const int32_t *r=results;
181 UErrorCode errorCode=U_ZERO_ERROR;
182 UChar32 c;
183
184 while(s<limit) {
185 s0=s;
186 c=ucnv_getNextUChar(cnv, &s, limit, &errorCode);
187 if(errorCode==U_INDEX_OUTOFBOUNDS_ERROR) {
188 break; /* no more significant input */
189 } else if(U_FAILURE(errorCode)) {
190 log_err("%s ucnv_getNextUChar() failed: %s\n", message, u_errorName(errorCode));
191 break;
192 } else if(
193 /* test the expected number of input bytes only if >=0 */
194 (*r>=0 && (int32_t)(s-s0)!=*r) ||
195 c!=*(r+1)
196 ) {
197 log_err("%s ucnv_getNextUChar() result %lx from %d bytes, should have been %lx from %d bytes.\n",
198 message, c, (s-s0), *(r+1), *r);
199 break;
200 }
201 r+=2;
202 }
203 }
204
205 static void
206 TestNextUCharError(UConverter* cnv, const char* source, const char* limit, UErrorCode expected, const char* message)
207 {
208 const char* s=(char*)source;
209 UErrorCode errorCode=U_ZERO_ERROR;
210 uint32_t c;
211 c=ucnv_getNextUChar(cnv, &s, limit, &errorCode);
212 if(errorCode != expected){
213 log_err("FAIL: Expected:%s when %s-----Got:%s\n", myErrorName(expected), message, myErrorName(errorCode));
214 }
215 if(c != 0xFFFD && c != 0xffff){
216 log_err("FAIL: Expected return value of 0xfffd or 0xffff when %s-----Got 0x%lx\n", message, c);
217 }
218
219 }
220
221 static void TestInBufSizes(void)
222 {
223 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,1);
224 #if 1
225 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,2);
226 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,3);
227 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,4);
228 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,5);
229 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,6);
230 TestNewConvertWithBufferSizes(1,1);
231 TestNewConvertWithBufferSizes(2,3);
232 TestNewConvertWithBufferSizes(3,2);
233 #endif
234 }
235
236 static void TestOutBufSizes(void)
237 {
238 #if 1
239 TestNewConvertWithBufferSizes(NEW_MAX_BUFFER,NEW_MAX_BUFFER);
240 TestNewConvertWithBufferSizes(1,NEW_MAX_BUFFER);
241 TestNewConvertWithBufferSizes(2,NEW_MAX_BUFFER);
242 TestNewConvertWithBufferSizes(3,NEW_MAX_BUFFER);
243 TestNewConvertWithBufferSizes(4,NEW_MAX_BUFFER);
244 TestNewConvertWithBufferSizes(5,NEW_MAX_BUFFER);
245
246 #endif
247 }
248
249
250 void addTestNewConvert(TestNode** root)
251 {
252 #if !UCONFIG_NO_FILE_IO
253 addTest(root, &TestInBufSizes, "tsconv/nucnvtst/TestInBufSizes");
254 addTest(root, &TestOutBufSizes, "tsconv/nucnvtst/TestOutBufSizes");
255 #endif
256 addTest(root, &TestConverterTypesAndStarters, "tsconv/nucnvtst/TestConverterTypesAndStarters");
257 addTest(root, &TestAmbiguous, "tsconv/nucnvtst/TestAmbiguous");
258 addTest(root, &TestSignatureDetection, "tsconv/nucnvtst/TestSignatureDetection");
259 addTest(root, &TestUTF7, "tsconv/nucnvtst/TestUTF7");
260 addTest(root, &TestIMAP, "tsconv/nucnvtst/TestIMAP");
261 addTest(root, &TestUTF8, "tsconv/nucnvtst/TestUTF8");
262
263 /* test ucnv_getNextUChar() for charsets that encode single surrogates with complete byte sequences */
264 addTest(root, &TestCESU8, "tsconv/nucnvtst/TestCESU8");
265 addTest(root, &TestUTF16, "tsconv/nucnvtst/TestUTF16");
266 addTest(root, &TestUTF16BE, "tsconv/nucnvtst/TestUTF16BE");
267 addTest(root, &TestUTF16LE, "tsconv/nucnvtst/TestUTF16LE");
268 addTest(root, &TestUTF32, "tsconv/nucnvtst/TestUTF32");
269 addTest(root, &TestUTF32BE, "tsconv/nucnvtst/TestUTF32BE");
270 addTest(root, &TestUTF32LE, "tsconv/nucnvtst/TestUTF32LE");
271
272 #if !UCONFIG_NO_LEGACY_CONVERSION
273 addTest(root, &TestLMBCS, "tsconv/nucnvtst/TestLMBCS");
274 #endif
275
276 addTest(root, &TestLATIN1, "tsconv/nucnvtst/TestLATIN1");
277
278 #if !UCONFIG_NO_LEGACY_CONVERSION
279 addTest(root, &TestSBCS, "tsconv/nucnvtst/TestSBCS");
280 #if !UCONFIG_NO_FILE_IO
281 addTest(root, &TestDBCS, "tsconv/nucnvtst/TestDBCS");
282 addTest(root, &TestICCRunout, "tsconv/nucnvtst/TestICCRunout");
283 #endif
284 addTest(root, &TestMBCS, "tsconv/nucnvtst/TestMBCS");
285
286 #ifdef U_ENABLE_GENERIC_ISO_2022
287 addTest(root, &TestISO_2022, "tsconv/nucnvtst/TestISO_2022");
288 #endif
289
290 addTest(root, &TestISO_2022_JP, "tsconv/nucnvtst/TestISO_2022_JP");
291 addTest(root, &TestJIS, "tsconv/nucnvtst/TestJIS");
292 addTest(root, &TestISO_2022_JP_1, "tsconv/nucnvtst/TestISO_2022_JP_1");
293 addTest(root, &TestISO_2022_JP_2, "tsconv/nucnvtst/TestISO_2022_JP_2");
294 addTest(root, &TestISO_2022_KR, "tsconv/nucnvtst/TestISO_2022_KR");
295 addTest(root, &TestISO_2022_KR_1, "tsconv/nucnvtst/TestISO_2022_KR_1");
296 addTest(root, &TestISO_2022_CN, "tsconv/nucnvtst/TestISO_2022_CN");
297 /*
298 * ICU 4.4 (ticket #7314) removes mappings for CNS 11643 planes 3..7
299 addTest(root, &TestISO_2022_CN_EXT, "tsconv/nucnvtst/TestISO_2022_CN_EXT");
300 addTest(root, &TestJitterbug915, "tsconv/nucnvtst/TestJitterbug915");
301 */
302 addTest(root, &TestHZ, "tsconv/nucnvtst/TestHZ");
303 #endif
304
305 addTest(root, &TestSCSU, "tsconv/nucnvtst/TestSCSU");
306
307 #if !UCONFIG_NO_LEGACY_CONVERSION
308 addTest(root, &TestEBCDIC_STATEFUL, "tsconv/nucnvtst/TestEBCDIC_STATEFUL");
309 addTest(root, &TestGB18030, "tsconv/nucnvtst/TestGB18030");
310 addTest(root, &TestJitterbug255, "tsconv/nucnvtst/TestJitterbug255");
311 addTest(root, &TestEBCDICUS4XML, "tsconv/nucnvtst/TestEBCDICUS4XML");
312 addTest(root, &TestISCII, "tsconv/nucnvtst/TestISCII");
313 addTest(root, &TestJB5275, "tsconv/nucnvtst/TestJB5275");
314 addTest(root, &TestJB5275_1, "tsconv/nucnvtst/TestJB5275_1");
315 #if !UCONFIG_NO_COLLATION
316 addTest(root, &TestJitterbug981, "tsconv/nucnvtst/TestJitterbug981");
317 #endif
318
319 addTest(root, &TestJitterbug1293, "tsconv/nucnvtst/TestJitterbug1293");
320 #endif
321
322
323 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_NO_FILE_IO
324 addTest(root, &TestCoverageMBCS, "tsconv/nucnvtst/TestCoverageMBCS");
325 #endif
326
327 addTest(root, &TestRoundTrippingAllUTF, "tsconv/nucnvtst/TestRoundTrippingAllUTF");
328
329 #if !UCONFIG_NO_LEGACY_CONVERSION
330 addTest(root, &TestJitterbug2346, "tsconv/nucnvtst/TestJitterbug2346");
331 addTest(root, &TestJitterbug2411, "tsconv/nucnvtst/TestJitterbug2411");
332 addTest(root, &TestJitterbug6175, "tsconv/nucnvtst/TestJitterbug6175");
333
334 addTest(root, &TestIsFixedWidth, "tsconv/nucnvtst/TestIsFixedWidth");
335 #endif
336 }
337
338
339 /* Note that this test already makes use of statics, so it's not really
340 multithread safe.
341 This convenience function lets us make the error messages actually useful.
342 */
343
344 static void setNuConvTestName(const char *codepage, const char *direction)
345 {
346 sprintf(gNuConvTestName, "[Testing %s %s Unicode, InputBufSiz=%d, OutputBufSiz=%d]",
347 codepage,
348 direction,
349 (int)gInBufferSize,
350 (int)gOutBufferSize);
351 }
352
353 typedef enum
354 {
355 TC_OK = 0, /* test was OK */
356 TC_MISMATCH = 1, /* Match failed - err was printed */
357 TC_FAIL = 2 /* Test failed, don't print an err because it was already printed. */
358 } ETestConvertResult;
359
360 /* Note: This function uses global variables and it will not do offset
361 checking without gOutBufferSize and gInBufferSize set to NEW_MAX_BUFFER */
362 static ETestConvertResult testConvertFromU( const UChar *source, int sourceLen, const uint8_t *expect, int expectLen,
363 const char *codepage, const int32_t *expectOffsets , UBool useFallback)
364 {
365 UErrorCode status = U_ZERO_ERROR;
366 UConverter *conv = 0;
367 char junkout[NEW_MAX_BUFFER]; /* FIX */
368 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
369 char *p;
370 const UChar *src;
371 char *end;
372 char *targ;
373 int32_t *offs;
374 int i;
375 int32_t realBufferSize;
376 char *realBufferEnd;
377 const UChar *realSourceEnd;
378 const UChar *sourceLimit;
379 UBool checkOffsets = TRUE;
380 UBool doFlush;
381
382 for(i=0;i<NEW_MAX_BUFFER;i++)
383 junkout[i] = (char)0xF0;
384 for(i=0;i<NEW_MAX_BUFFER;i++)
385 junokout[i] = 0xFF;
386
387 setNuConvTestName(codepage, "FROM");
388
389 log_verbose("\n========= %s\n", gNuConvTestName);
390
391 conv = my_ucnv_open(codepage, &status);
392
393 if(U_FAILURE(status))
394 {
395 log_data_err("Couldn't open converter %s\n",codepage);
396 return TC_FAIL;
397 }
398 if(useFallback){
399 ucnv_setFallback(conv,useFallback);
400 }
401
402 log_verbose("Converter opened..\n");
403
404 src = source;
405 targ = junkout;
406 offs = junokout;
407
408 realBufferSize = UPRV_LENGTHOF(junkout);
409 realBufferEnd = junkout + realBufferSize;
410 realSourceEnd = source + sourceLen;
411
412 if ( gOutBufferSize != realBufferSize || gInBufferSize != NEW_MAX_BUFFER )
413 checkOffsets = FALSE;
414
415 do
416 {
417 end = nct_min(targ + gOutBufferSize, realBufferEnd);
418 sourceLimit = nct_min(src + gInBufferSize, realSourceEnd);
419
420 doFlush = (UBool)(sourceLimit == realSourceEnd);
421
422 if(targ == realBufferEnd) {
423 log_err("Error, overflowed the real buffer while about to call fromUnicode! targ=%08lx %s", targ, gNuConvTestName);
424 return TC_FAIL;
425 }
426 log_verbose("calling fromUnicode @ SOURCE:%08lx to %08lx TARGET: %08lx to %08lx, flush=%s\n", src,sourceLimit, targ,end, doFlush?"TRUE":"FALSE");
427
428
429 status = U_ZERO_ERROR;
430
431 ucnv_fromUnicode (conv,
432 &targ,
433 end,
434 &src,
435 sourceLimit,
436 checkOffsets ? offs : NULL,
437 doFlush, /* flush if we're at the end of the input data */
438 &status);
439 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && sourceLimit < realSourceEnd) );
440
441 if(U_FAILURE(status)) {
442 log_err("Problem doing fromUnicode to %s, errcode %s %s\n", codepage, myErrorName(status), gNuConvTestName);
443 return TC_FAIL;
444 }
445
446 log_verbose("\nConversion done [%d uchars in -> %d chars out]. \nResult :",
447 sourceLen, targ-junkout);
448
449 if(getTestOption(VERBOSITY_OPTION))
450 {
451 char junk[9999];
452 char offset_str[9999];
453 char *ptr;
454
455 junk[0] = 0;
456 offset_str[0] = 0;
457 for(ptr = junkout;ptr<targ;ptr++) {
458 sprintf(junk + strlen(junk), "0x%02x, ", (int)(0xFF & *ptr));
459 sprintf(offset_str + strlen(offset_str), "0x%02x, ", (int)(0xFF & junokout[ptr-junkout]));
460 }
461
462 log_verbose(junk);
463 printSeq((const uint8_t *)expect, expectLen);
464 if ( checkOffsets ) {
465 log_verbose("\nOffsets:");
466 log_verbose(offset_str);
467 }
468 log_verbose("\n");
469 }
470 ucnv_close(conv);
471
472 if(expectLen != targ-junkout) {
473 log_err("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
474 log_verbose("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
475 fprintf(stderr, "Got:\n");
476 printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
477 fprintf(stderr, "Expected:\n");
478 printSeqErr((const unsigned char*)expect, expectLen);
479 return TC_MISMATCH;
480 }
481
482 if (checkOffsets && (expectOffsets != 0) ) {
483 log_verbose("comparing %d offsets..\n", targ-junkout);
484 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t) )){
485 log_err("did not get the expected offsets. %s\n", gNuConvTestName);
486 printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
487 log_err("\n");
488 log_err("Got : ");
489 for(p=junkout;p<targ;p++) {
490 log_err("%d,", junokout[p-junkout]);
491 }
492 log_err("\n");
493 log_err("Expected: ");
494 for(i=0; i<(targ-junkout); i++) {
495 log_err("%d,", expectOffsets[i]);
496 }
497 log_err("\n");
498 }
499 }
500
501 log_verbose("comparing..\n");
502 if(!memcmp(junkout, expect, expectLen)) {
503 log_verbose("Matches!\n");
504 return TC_OK;
505 } else {
506 log_err("String does not match u->%s\n", gNuConvTestName);
507 printUSeqErr(source, sourceLen);
508 fprintf(stderr, "Got:\n");
509 printSeqErr((const unsigned char *)junkout, expectLen);
510 fprintf(stderr, "Expected:\n");
511 printSeqErr((const unsigned char *)expect, expectLen);
512
513 return TC_MISMATCH;
514 }
515 }
516
517 /* Note: This function uses global variables and it will not do offset
518 checking without gOutBufferSize and gInBufferSize set to NEW_MAX_BUFFER */
519 static ETestConvertResult testConvertToU( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen,
520 const char *codepage, const int32_t *expectOffsets, UBool useFallback)
521 {
522 UErrorCode status = U_ZERO_ERROR;
523 UConverter *conv = 0;
524 UChar junkout[NEW_MAX_BUFFER]; /* FIX */
525 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
526 const char *src;
527 const char *realSourceEnd;
528 const char *srcLimit;
529 UChar *p;
530 UChar *targ;
531 UChar *end;
532 int32_t *offs;
533 int i;
534 UBool checkOffsets = TRUE;
535
536 int32_t realBufferSize;
537 UChar *realBufferEnd;
538
539
540 for(i=0;i<NEW_MAX_BUFFER;i++)
541 junkout[i] = 0xFFFE;
542
543 for(i=0;i<NEW_MAX_BUFFER;i++)
544 junokout[i] = -1;
545
546 setNuConvTestName(codepage, "TO");
547
548 log_verbose("\n========= %s\n", gNuConvTestName);
549
550 conv = my_ucnv_open(codepage, &status);
551
552 if(U_FAILURE(status))
553 {
554 log_data_err("Couldn't open converter %s\n",gNuConvTestName);
555 return TC_FAIL;
556 }
557 if(useFallback){
558 ucnv_setFallback(conv,useFallback);
559 }
560 log_verbose("Converter opened..\n");
561
562 src = (const char *)source;
563 targ = junkout;
564 offs = junokout;
565
566 realBufferSize = UPRV_LENGTHOF(junkout);
567 realBufferEnd = junkout + realBufferSize;
568 realSourceEnd = src + sourcelen;
569
570 if ( gOutBufferSize != realBufferSize || gInBufferSize != NEW_MAX_BUFFER )
571 checkOffsets = FALSE;
572
573 do
574 {
575 end = nct_min( targ + gOutBufferSize, realBufferEnd);
576 srcLimit = nct_min(realSourceEnd, src + gInBufferSize);
577
578 if(targ == realBufferEnd)
579 {
580 log_err("Error, the end would overflow the real output buffer while about to call toUnicode! tarjet=%08lx %s",targ,gNuConvTestName);
581 return TC_FAIL;
582 }
583 log_verbose("calling toUnicode @ %08lx to %08lx\n", targ,end);
584
585 /* oldTarg = targ; */
586
587 status = U_ZERO_ERROR;
588
589 ucnv_toUnicode (conv,
590 &targ,
591 end,
592 &src,
593 srcLimit,
594 checkOffsets ? offs : NULL,
595 (UBool)(srcLimit == realSourceEnd), /* flush if we're at the end of hte source data */
596 &status);
597
598 /* offs += (targ-oldTarg); */
599
600 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && (srcLimit < realSourceEnd)) ); /* while we just need another buffer */
601
602 if(U_FAILURE(status))
603 {
604 log_err("Problem doing %s toUnicode, errcode %s %s\n", codepage, myErrorName(status), gNuConvTestName);
605 return TC_FAIL;
606 }
607
608 log_verbose("\nConversion done. %d bytes -> %d chars.\nResult :",
609 sourcelen, targ-junkout);
610 if(getTestOption(VERBOSITY_OPTION))
611 {
612 char junk[9999];
613 char offset_str[9999];
614 UChar *ptr;
615
616 junk[0] = 0;
617 offset_str[0] = 0;
618
619 for(ptr = junkout;ptr<targ;ptr++)
620 {
621 sprintf(junk + strlen(junk), "0x%04x, ", (0xFFFF) & (unsigned int)*ptr);
622 sprintf(offset_str + strlen(offset_str), "0x%04x, ", (0xFFFF) & (unsigned int)junokout[ptr-junkout]);
623 }
624
625 log_verbose(junk);
626 printUSeq(expect, expectlen);
627 if ( checkOffsets )
628 {
629 log_verbose("\nOffsets:");
630 log_verbose(offset_str);
631 }
632 log_verbose("\n");
633 }
634 ucnv_close(conv);
635
636 log_verbose("comparing %d uchars (%d bytes)..\n",expectlen,expectlen*2);
637
638 if (checkOffsets && (expectOffsets != 0))
639 {
640 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t))){
641 log_err("did not get the expected offsets. %s\n",gNuConvTestName);
642 log_err("Got: ");
643 for(p=junkout;p<targ;p++) {
644 log_err("%d,", junokout[p-junkout]);
645 }
646 log_err("\n");
647 log_err("Expected: ");
648 for(i=0; i<(targ-junkout); i++) {
649 log_err("%d,", expectOffsets[i]);
650 }
651 log_err("\n");
652 log_err("output: ");
653 for(i=0; i<(targ-junkout); i++) {
654 log_err("%X,", junkout[i]);
655 }
656 log_err("\n");
657 log_err("input: ");
658 for(i=0; i<(src-(const char *)source); i++) {
659 log_err("%X,", (unsigned char)source[i]);
660 }
661 log_err("\n");
662 }
663 }
664
665 if(!memcmp(junkout, expect, expectlen*2))
666 {
667 log_verbose("Matches!\n");
668 return TC_OK;
669 }
670 else
671 {
672 log_err("String does not match. %s\n", gNuConvTestName);
673 log_verbose("String does not match. %s\n", gNuConvTestName);
674 printf("\nGot:");
675 printUSeqErr(junkout, expectlen);
676 printf("\nExpected:");
677 printUSeqErr(expect, expectlen);
678 return TC_MISMATCH;
679 }
680 }
681
682
683 static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
684 {
685 /** test chars #1 */
686 /* 1 2 3 1Han 2Han 3Han . */
687 static const UChar sampleText[] =
688 { 0x0031, 0x0032, 0x0033, 0x0000, 0x4e00, 0x4e8c, 0x4e09, 0x002E, 0xD840, 0xDC21 };
689 static const UChar sampleTextRoundTripUnmappable[] =
690 { 0x0031, 0x0032, 0x0033, 0x0000, 0x4e00, 0x4e8c, 0x4e09, 0x002E, 0xfffd };
691
692
693 static const uint8_t expectedUTF8[] =
694 { 0x31, 0x32, 0x33, 0x00, 0xe4, 0xb8, 0x80, 0xe4, 0xba, 0x8c, 0xe4, 0xb8, 0x89, 0x2E, 0xf0, 0xa0, 0x80, 0xa1 };
695 static const int32_t toUTF8Offs[] =
696 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x08, 0x08, 0x08, 0x08 };
697 static const int32_t fmUTF8Offs[] =
698 { 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0007, 0x000a, 0x000d, 0x000e, 0x000e };
699
700 #ifdef U_ENABLE_GENERIC_ISO_2022
701 /* Same as UTF8, but with ^[%B preceeding */
702 static const const uint8_t expectedISO2022[] =
703 { 0x1b, 0x25, 0x42, 0x31, 0x32, 0x33, 0x00, 0xe4, 0xb8, 0x80, 0xe4, 0xba, 0x8c, 0xe4, 0xb8, 0x89, 0x2E };
704 static const int32_t toISO2022Offs[] =
705 { -1, -1, -1, 0x00, 0x01, 0x02, 0x03, 0x04, 0x04,
706 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07 }; /* right? */
707 static const int32_t fmISO2022Offs[] =
708 { 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x000a, 0x000d, 0x0010 }; /* is this right? */
709 #endif
710
711 /* 1 2 3 0, <SO> h1 h2 h3 <SI> . EBCDIC_STATEFUL */
712 static const uint8_t expectedIBM930[] =
713 { 0xF1, 0xF2, 0xF3, 0x00, 0x0E, 0x45, 0x41, 0x45, 0x42, 0x45, 0x43, 0x0F, 0x4B, 0x0e, 0xfe, 0xfe, 0x0f };
714 static const int32_t toIBM930Offs[] =
715 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, -1 };
716 static const int32_t fmIBM930Offs[] =
717 { 0x0000, 0x0001, 0x0002, 0x0003, 0x0005, 0x0007, 0x0009, 0x000c, 0x000e };
718
719 /* 1 2 3 0 h1 h2 h3 . MBCS*/
720 static const uint8_t expectedIBM943[] =
721 { 0x31, 0x32, 0x33, 0x00, 0x88, 0xea, 0x93, 0xf1, 0x8e, 0x4f, 0x2e, 0xfc, 0xfc };
722 static const int32_t toIBM943Offs [] =
723 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08 };
724 static const int32_t fmIBM943Offs[] =
725 { 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0006, 0x0008, 0x000a, 0x000b };
726
727 /* 1 2 3 0 h1 h2 h3 . DBCS*/
728 static const uint8_t expectedIBM9027[] =
729 { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x4c, 0x41, 0x4c, 0x48, 0x4c, 0x55, 0xfe, 0xfe, 0xfe, 0xfe };
730 static const int32_t toIBM9027Offs [] =
731 { 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08 };
732
733 /* 1 2 3 0 <?> <?> <?> . SBCS*/
734 static const uint8_t expectedIBM920[] =
735 { 0x31, 0x32, 0x33, 0x00, 0x1a, 0x1a, 0x1a, 0x2e, 0x1a };
736 static const int32_t toIBM920Offs [] =
737 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
738
739 /* 1 2 3 0 <?> <?> <?> . SBCS*/
740 static const uint8_t expectedISO88593[] =
741 { 0x31, 0x32, 0x33, 0x00, 0x1a, 0x1a, 0x1a, 0x2E, 0x1a };
742 static const int32_t toISO88593Offs[] =
743 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
744
745 /* 1 2 3 0 <?> <?> <?> . <?> LATIN_1*/
746 static const uint8_t expectedLATIN1[] =
747 { 0x31, 0x32, 0x33, 0x00, 0x1a, 0x1a, 0x1a, 0x2E, 0x1a };
748 static const int32_t toLATIN1Offs[] =
749 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
750
751
752 /* etc */
753 static const uint8_t expectedUTF16BE[] =
754 { 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x00, 0x4e, 0x00, 0x4e, 0x8c, 0x4e, 0x09, 0x00, 0x2e, 0xd8, 0x40, 0xdc, 0x21 };
755 static const int32_t toUTF16BEOffs[]=
756 { 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08 };
757 static const int32_t fmUTF16BEOffs[] =
758 { 0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e, 0x0010, 0x0010 };
759
760 static const uint8_t expectedUTF16LE[] =
761 { 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x8c, 0x4e, 0x09, 0x4e, 0x2e, 0x00, 0x40, 0xd8, 0x21, 0xdc };
762 static const int32_t toUTF16LEOffs[]=
763 { 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08 };
764 static const int32_t fmUTF16LEOffs[] =
765 { 0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000a, 0x000c, 0x000e, 0x0010, 0x0010 };
766
767 static const uint8_t expectedUTF32BE[] =
768 { 0x00, 0x00, 0x00, 0x31,
769 0x00, 0x00, 0x00, 0x32,
770 0x00, 0x00, 0x00, 0x33,
771 0x00, 0x00, 0x00, 0x00,
772 0x00, 0x00, 0x4e, 0x00,
773 0x00, 0x00, 0x4e, 0x8c,
774 0x00, 0x00, 0x4e, 0x09,
775 0x00, 0x00, 0x00, 0x2e,
776 0x00, 0x02, 0x00, 0x21 };
777 static const int32_t toUTF32BEOffs[]=
778 { 0x00, 0x00, 0x00, 0x00,
779 0x01, 0x01, 0x01, 0x01,
780 0x02, 0x02, 0x02, 0x02,
781 0x03, 0x03, 0x03, 0x03,
782 0x04, 0x04, 0x04, 0x04,
783 0x05, 0x05, 0x05, 0x05,
784 0x06, 0x06, 0x06, 0x06,
785 0x07, 0x07, 0x07, 0x07,
786 0x08, 0x08, 0x08, 0x08,
787 0x08, 0x08, 0x08, 0x08 };
788 static const int32_t fmUTF32BEOffs[] =
789 { 0x0000, 0x0004, 0x0008, 0x000c, 0x0010, 0x0014, 0x0018, 0x001c, 0x0020, 0x0020 };
790
791 static const uint8_t expectedUTF32LE[] =
792 { 0x31, 0x00, 0x00, 0x00,
793 0x32, 0x00, 0x00, 0x00,
794 0x33, 0x00, 0x00, 0x00,
795 0x00, 0x00, 0x00, 0x00,
796 0x00, 0x4e, 0x00, 0x00,
797 0x8c, 0x4e, 0x00, 0x00,
798 0x09, 0x4e, 0x00, 0x00,
799 0x2e, 0x00, 0x00, 0x00,
800 0x21, 0x00, 0x02, 0x00 };
801 static const int32_t toUTF32LEOffs[]=
802 { 0x00, 0x00, 0x00, 0x00,
803 0x01, 0x01, 0x01, 0x01,
804 0x02, 0x02, 0x02, 0x02,
805 0x03, 0x03, 0x03, 0x03,
806 0x04, 0x04, 0x04, 0x04,
807 0x05, 0x05, 0x05, 0x05,
808 0x06, 0x06, 0x06, 0x06,
809 0x07, 0x07, 0x07, 0x07,
810 0x08, 0x08, 0x08, 0x08,
811 0x08, 0x08, 0x08, 0x08 };
812 static const int32_t fmUTF32LEOffs[] =
813 { 0x0000, 0x0004, 0x0008, 0x000c, 0x0010, 0x0014, 0x0018, 0x001c, 0x0020, 0x0020 };
814
815
816
817
818 /** Test chars #2 **/
819
820 /* Sahha [health], slashed h's */
821 static const UChar malteseUChars[] = { 0x0053, 0x0061, 0x0127, 0x0127, 0x0061 };
822 static const uint8_t expectedMaltese913[] = { 0x53, 0x61, 0xB1, 0xB1, 0x61 };
823
824 /* LMBCS */
825 static const UChar LMBCSUChars[] = { 0x0027, 0x010A, 0x0000, 0x0127, 0x2666, 0x0220 };
826 static const uint8_t expectedLMBCS[] = { 0x27, 0x06, 0x04, 0x00, 0x01, 0x73, 0x01, 0x04, 0x14, 0x02, 0x20 };
827 static const int32_t toLMBCSOffs[] = { 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x04 , 0x05, 0x05, 0x05 };
828 static const int32_t fmLMBCSOffs[] = { 0x0000, 0x0001, 0x0003, 0x0004, 0x0006, 0x0008};
829 /*********************************** START OF CODE finally *************/
830
831 gInBufferSize = insize;
832 gOutBufferSize = outsize;
833
834 log_verbose("\n\n\nTesting conversions with InputBufferSize = %d, OutputBufferSize = %d\n", gInBufferSize, gOutBufferSize);
835
836
837 /*UTF-8*/
838 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
839 expectedUTF8, sizeof(expectedUTF8), "UTF8", toUTF8Offs,FALSE );
840
841 log_verbose("Test surrogate behaviour for UTF8\n");
842 {
843 static const UChar testinput[]={ 0x20ac, 0xd801, 0xdc01, 0xdc01 };
844 static const uint8_t expectedUTF8test2[]= { 0xe2, 0x82, 0xac,
845 0xf0, 0x90, 0x90, 0x81,
846 0xef, 0xbf, 0xbd
847 };
848 static const int32_t offsets[]={ 0, 0, 0, 1, 1, 1, 1, 3, 3, 3 };
849 testConvertFromU(testinput, UPRV_LENGTHOF(testinput),
850 expectedUTF8test2, sizeof(expectedUTF8test2), "UTF8", offsets,FALSE );
851
852
853 }
854
855 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
856 /*ISO-2022*/
857 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
858 expectedISO2022, sizeof(expectedISO2022), "ISO_2022", toISO2022Offs,FALSE );
859 #endif
860
861 /*UTF16 LE*/
862 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
863 expectedUTF16LE, sizeof(expectedUTF16LE), "utf-16le", toUTF16LEOffs,FALSE );
864 /*UTF16 BE*/
865 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
866 expectedUTF16BE, sizeof(expectedUTF16BE), "utf-16be", toUTF16BEOffs,FALSE );
867 /*UTF32 LE*/
868 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
869 expectedUTF32LE, sizeof(expectedUTF32LE), "utf-32le", toUTF32LEOffs,FALSE );
870 /*UTF32 BE*/
871 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
872 expectedUTF32BE, sizeof(expectedUTF32BE), "utf-32be", toUTF32BEOffs,FALSE );
873
874 /*LATIN_1*/
875 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
876 expectedLATIN1, sizeof(expectedLATIN1), "LATIN_1", toLATIN1Offs,FALSE );
877
878 #if !UCONFIG_NO_LEGACY_CONVERSION
879 /*EBCDIC_STATEFUL*/
880 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
881 expectedIBM930, sizeof(expectedIBM930), "ibm-930", toIBM930Offs,FALSE );
882
883 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
884 expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
885
886 /*MBCS*/
887
888 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
889 expectedIBM943, sizeof(expectedIBM943), "ibm-943", toIBM943Offs,FALSE );
890 /*DBCS*/
891 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
892 expectedIBM9027, sizeof(expectedIBM9027), "@ibm9027", toIBM9027Offs,FALSE );
893 /*SBCS*/
894 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
895 expectedIBM920, sizeof(expectedIBM920), "ibm-920", toIBM920Offs,FALSE );
896 /*SBCS*/
897 testConvertFromU(sampleText, UPRV_LENGTHOF(sampleText),
898 expectedISO88593, sizeof(expectedISO88593), "iso-8859-3", toISO88593Offs,FALSE );
899 #endif
900
901
902 /****/
903
904 /*UTF-8*/
905 testConvertToU(expectedUTF8, sizeof(expectedUTF8),
906 sampleText, UPRV_LENGTHOF(sampleText), "utf8", fmUTF8Offs,FALSE);
907 #if !UCONFIG_NO_LEGACY_CONVERSION && defined(U_ENABLE_GENERIC_ISO_2022)
908 /*ISO-2022*/
909 testConvertToU(expectedISO2022, sizeof(expectedISO2022),
910 sampleText, UPRV_LENGTHOF(sampleText), "ISO_2022", fmISO2022Offs,FALSE);
911 #endif
912
913 /*UTF16 LE*/
914 testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),
915 sampleText, UPRV_LENGTHOF(sampleText), "utf-16le", fmUTF16LEOffs,FALSE);
916 /*UTF16 BE*/
917 testConvertToU(expectedUTF16BE, sizeof(expectedUTF16BE),
918 sampleText, UPRV_LENGTHOF(sampleText), "utf-16be", fmUTF16BEOffs,FALSE);
919 /*UTF32 LE*/
920 testConvertToU(expectedUTF32LE, sizeof(expectedUTF32LE),
921 sampleText, UPRV_LENGTHOF(sampleText), "utf-32le", fmUTF32LEOffs,FALSE);
922 /*UTF32 BE*/
923 testConvertToU(expectedUTF32BE, sizeof(expectedUTF32BE),
924 sampleText, UPRV_LENGTHOF(sampleText), "utf-32be", fmUTF32BEOffs,FALSE);
925
926 #if !UCONFIG_NO_LEGACY_CONVERSION
927 /*EBCDIC_STATEFUL*/
928 testConvertToU(expectedIBM930, sizeof(expectedIBM930), sampleTextRoundTripUnmappable,
929 UPRV_LENGTHOF(sampleTextRoundTripUnmappable), "ibm-930", fmIBM930Offs,FALSE);
930 /*MBCS*/
931 testConvertToU(expectedIBM943, sizeof(expectedIBM943),sampleTextRoundTripUnmappable,
932 UPRV_LENGTHOF(sampleTextRoundTripUnmappable), "ibm-943", fmIBM943Offs,FALSE);
933 #endif
934
935 /* Try it again to make sure it still works */
936 testConvertToU(expectedUTF16LE, sizeof(expectedUTF16LE),
937 sampleText, UPRV_LENGTHOF(sampleText), "utf-16le", fmUTF16LEOffs,FALSE);
938
939 #if !UCONFIG_NO_LEGACY_CONVERSION
940 testConvertToU(expectedMaltese913, sizeof(expectedMaltese913),
941 malteseUChars, UPRV_LENGTHOF(malteseUChars), "latin3", NULL,FALSE);
942
943 testConvertFromU(malteseUChars, UPRV_LENGTHOF(malteseUChars),
944 expectedMaltese913, sizeof(expectedMaltese913), "iso-8859-3", NULL,FALSE );
945
946 /*LMBCS*/
947 testConvertFromU(LMBCSUChars, UPRV_LENGTHOF(LMBCSUChars),
948 expectedLMBCS, sizeof(expectedLMBCS), "LMBCS-1", toLMBCSOffs,FALSE );
949 testConvertToU(expectedLMBCS, sizeof(expectedLMBCS),
950 LMBCSUChars, UPRV_LENGTHOF(LMBCSUChars), "LMBCS-1", fmLMBCSOffs,FALSE);
951 #endif
952
953 /* UTF-7 examples are mostly from http://www.imc.org/rfc2152 */
954 {
955 /* encode directly set D and set O */
956 static const uint8_t utf7[] = {
957 /*
958 Hi Mom -+Jjo--!
959 A+ImIDkQ.
960 +-
961 +ZeVnLIqe-
962 */
963 0x48, 0x69, 0x20, 0x4d, 0x6f, 0x6d, 0x20, 0x2d, 0x2b, 0x4a, 0x6a, 0x6f, 0x2d, 0x2d, 0x21,
964 0x41, 0x2b, 0x49, 0x6d, 0x49, 0x44, 0x6b, 0x51, 0x2e,
965 0x2b, 0x2d,
966 0x2b, 0x5a, 0x65, 0x56, 0x6e, 0x4c, 0x49, 0x71, 0x65, 0x2d
967 };
968 static const UChar unicode[] = {
969 /*
970 Hi Mom -<WHITE SMILING FACE>-!
971 A<NOT IDENTICAL TO><ALPHA>.
972 +
973 [Japanese word "nihongo"]
974 */
975 0x48, 0x69, 0x20, 0x4d, 0x6f, 0x6d, 0x20, 0x2d, 0x263a, 0x2d, 0x21,
976 0x41, 0x2262, 0x0391, 0x2e,
977 0x2b,
978 0x65e5, 0x672c, 0x8a9e
979 };
980 static const int32_t toUnicodeOffsets[] = {
981 0, 1, 2, 3, 4, 5, 6, 7, 9, 13, 14,
982 15, 17, 19, 23,
983 24,
984 27, 29, 32
985 };
986 static const int32_t fromUnicodeOffsets[] = {
987 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 9, 10,
988 11, 12, 12, 12, 13, 13, 13, 13, 14,
989 15, 15,
990 16, 16, 16, 17, 17, 17, 18, 18, 18, 18
991 };
992
993 /* same but escaping set O (the exclamation mark) */
994 static const uint8_t utf7Restricted[] = {
995 /*
996 Hi Mom -+Jjo--+ACE-
997 A+ImIDkQ.
998 +-
999 +ZeVnLIqe-
1000 */
1001 0x48, 0x69, 0x20, 0x4d, 0x6f, 0x6d, 0x20, 0x2d, 0x2b, 0x4a, 0x6a, 0x6f, 0x2d, 0x2d, 0x2b, 0x41, 0x43, 0x45, 0x2d,
1002 0x41, 0x2b, 0x49, 0x6d, 0x49, 0x44, 0x6b, 0x51, 0x2e,
1003 0x2b, 0x2d,
1004 0x2b, 0x5a, 0x65, 0x56, 0x6e, 0x4c, 0x49, 0x71, 0x65, 0x2d
1005 };
1006 static const int32_t toUnicodeOffsetsR[] = {
1007 0, 1, 2, 3, 4, 5, 6, 7, 9, 13, 15,
1008 19, 21, 23, 27,
1009 28,
1010 31, 33, 36
1011 };
1012 static const int32_t fromUnicodeOffsetsR[] = {
1013 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 9, 10, 10, 10, 10, 10,
1014 11, 12, 12, 12, 13, 13, 13, 13, 14,
1015 15, 15,
1016 16, 16, 16, 17, 17, 17, 18, 18, 18, 18
1017 };
1018
1019 testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7, sizeof(utf7), "UTF-7", fromUnicodeOffsets,FALSE);
1020
1021 testConvertToU(utf7, sizeof(utf7), unicode, UPRV_LENGTHOF(unicode), "UTF-7", toUnicodeOffsets,FALSE);
1022
1023 testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7Restricted, sizeof(utf7Restricted), "UTF-7,version=1", fromUnicodeOffsetsR,FALSE);
1024
1025 testConvertToU(utf7Restricted, sizeof(utf7Restricted), unicode, UPRV_LENGTHOF(unicode), "UTF-7,version=1", toUnicodeOffsetsR,FALSE);
1026 }
1027
1028 /*
1029 * IMAP-mailbox-name examples are mostly from http://www.imc.org/rfc2152,
1030 * modified according to RFC 2060,
1031 * and supplemented with the one example in RFC 2060 itself.
1032 */
1033 {
1034 static const uint8_t imap[] = {
1035 /* Hi Mom -&Jjo--!
1036 A&ImIDkQ-.
1037 &-
1038 &ZeVnLIqe-
1039 \
1040 ~peter
1041 /mail
1042 /&ZeVnLIqe-
1043 /&U,BTFw-
1044 */
1045 0x48, 0x69, 0x20, 0x4d, 0x6f, 0x6d, 0x20, 0x2d, 0x26, 0x4a, 0x6a, 0x6f, 0x2d, 0x2d, 0x21,
1046 0x41, 0x26, 0x49, 0x6d, 0x49, 0x44, 0x6b, 0x51, 0x2d, 0x2e,
1047 0x26, 0x2d,
1048 0x26, 0x5a, 0x65, 0x56, 0x6e, 0x4c, 0x49, 0x71, 0x65, 0x2d,
1049 0x5c,
1050 0x7e, 0x70, 0x65, 0x74, 0x65, 0x72,
1051 0x2f, 0x6d, 0x61, 0x69, 0x6c,
1052 0x2f, 0x26, 0x5a, 0x65, 0x56, 0x6e, 0x4c, 0x49, 0x71, 0x65, 0x2d,
1053 0x2f, 0x26, 0x55, 0x2c, 0x42, 0x54, 0x46, 0x77, 0x2d
1054 };
1055 static const UChar unicode[] = {
1056 /* Hi Mom -<WHITE SMILING FACE>-!
1057 A<NOT IDENTICAL TO><ALPHA>.
1058 &
1059 [Japanese word "nihongo"]
1060 \
1061 ~peter
1062 /mail
1063 /<65e5, 672c, 8a9e>
1064 /<53f0, 5317>
1065 */
1066 0x48, 0x69, 0x20, 0x4d, 0x6f, 0x6d, 0x20, 0x2d, 0x263a, 0x2d, 0x21,
1067 0x41, 0x2262, 0x0391, 0x2e,
1068 0x26,
1069 0x65e5, 0x672c, 0x8a9e,
1070 0x5c,
1071 0x7e, 0x70, 0x65, 0x74, 0x65, 0x72,
1072 0x2f, 0x6d, 0x61, 0x69, 0x6c,
1073 0x2f, 0x65e5, 0x672c, 0x8a9e,
1074 0x2f, 0x53f0, 0x5317
1075 };
1076 static const int32_t toUnicodeOffsets[] = {
1077 0, 1, 2, 3, 4, 5, 6, 7, 9, 13, 14,
1078 15, 17, 19, 24,
1079 25,
1080 28, 30, 33,
1081 37,
1082 38, 39, 40, 41, 42, 43,
1083 44, 45, 46, 47, 48,
1084 49, 51, 53, 56,
1085 60, 62, 64
1086 };
1087 static const int32_t fromUnicodeOffsets[] = {
1088 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 9, 10,
1089 11, 12, 12, 12, 13, 13, 13, 13, 13, 14,
1090 15, 15,
1091 16, 16, 16, 17, 17, 17, 18, 18, 18, 18,
1092 19,
1093 20, 21, 22, 23, 24, 25,
1094 26, 27, 28, 29, 30,
1095 31, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34,
1096 35, 36, 36, 36, 37, 37, 37, 37, 37
1097 };
1098
1099 testConvertFromU(unicode, UPRV_LENGTHOF(unicode), imap, sizeof(imap), "IMAP-mailbox-name", fromUnicodeOffsets,FALSE);
1100
1101 testConvertToU(imap, sizeof(imap), unicode, UPRV_LENGTHOF(unicode), "IMAP-mailbox-name", toUnicodeOffsets,FALSE);
1102 }
1103
1104 /* Test UTF-8 bad data handling*/
1105 {
1106 static const uint8_t utf8[]={
1107 0x61,
1108 0xf7, 0xbf, 0xbf, 0xbf, /* > 10FFFF */
1109 0x00,
1110 0x62,
1111 0xfb, 0xbf, 0xbf, 0xbf, 0xbf, /* > 10FFFF */
1112 0xfb, 0xbf, 0xbf, 0xbf, 0xbf, /* > 10FFFF */
1113 0xf4, 0x8f, 0xbf, 0xbf, /* 10FFFF */
1114 0xdf, 0xbf, /* 7ff */
1115 0xbf, /* truncated tail */
1116 0xf4, 0x90, 0x80, 0x80, /* 11FFFF */
1117 0x02
1118 };
1119
1120 static const uint16_t utf8Expected[]={
1121 0x0061,
1122 0xfffd,
1123 0x0000,
1124 0x0062,
1125 0xfffd,
1126 0xfffd,
1127 0xdbff, 0xdfff,
1128 0x07ff,
1129 0xfffd,
1130 0xfffd,
1131 0x0002
1132 };
1133
1134 static const int32_t utf8Offsets[]={
1135 0, 1, 5, 6, 7, 12, 17, 17, 21, 23, 24, 28
1136 };
1137 testConvertToU(utf8, sizeof(utf8),
1138 utf8Expected, UPRV_LENGTHOF(utf8Expected), "utf-8", utf8Offsets ,FALSE);
1139
1140 }
1141
1142 /* Test UTF-32BE bad data handling*/
1143 {
1144 static const uint8_t utf32[]={
1145 0x00, 0x00, 0x00, 0x61,
1146 0x00, 0x11, 0x00, 0x00, /* 0x110000 out of range */
1147 0x00, 0x10, 0xff, 0xff, /* 0x10FFFF in range */
1148 0x00, 0x00, 0x00, 0x62,
1149 0xff, 0xff, 0xff, 0xff, /* 0xffffffff out of range */
1150 0x7f, 0xff, 0xff, 0xff, /* 0x7fffffff out of range */
1151 0x00, 0x00, 0x01, 0x62,
1152 0x00, 0x00, 0x02, 0x62
1153 };
1154 static const uint16_t utf32Expected[]={
1155 0x0061,
1156 0xfffd, /* 0x110000 out of range */
1157 0xDBFF, /* 0x10FFFF in range */
1158 0xDFFF,
1159 0x0062,
1160 0xfffd, /* 0xffffffff out of range */
1161 0xfffd, /* 0x7fffffff out of range */
1162 0x0162,
1163 0x0262
1164 };
1165 static const int32_t utf32Offsets[]={
1166 0, 4, 8, 8, 12, 16, 20, 24, 28
1167 };
1168 static const uint8_t utf32ExpectedBack[]={
1169 0x00, 0x00, 0x00, 0x61,
1170 0x00, 0x00, 0xff, 0xfd, /* 0x110000 out of range */
1171 0x00, 0x10, 0xff, 0xff, /* 0x10FFFF in range */
1172 0x00, 0x00, 0x00, 0x62,
1173 0x00, 0x00, 0xff, 0xfd, /* 0xffffffff out of range */
1174 0x00, 0x00, 0xff, 0xfd, /* 0x7fffffff out of range */
1175 0x00, 0x00, 0x01, 0x62,
1176 0x00, 0x00, 0x02, 0x62
1177 };
1178 static const int32_t utf32OffsetsBack[]={
1179 0,0,0,0,
1180 1,1,1,1,
1181 2,2,2,2,
1182 4,4,4,4,
1183 5,5,5,5,
1184 6,6,6,6,
1185 7,7,7,7,
1186 8,8,8,8
1187 };
1188
1189 testConvertToU(utf32, sizeof(utf32),
1190 utf32Expected, UPRV_LENGTHOF(utf32Expected), "utf-32be", utf32Offsets ,FALSE);
1191 testConvertFromU(utf32Expected, UPRV_LENGTHOF(utf32Expected),
1192 utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32be", utf32OffsetsBack, FALSE);
1193 }
1194
1195 /* Test UTF-32LE bad data handling*/
1196 {
1197 static const uint8_t utf32[]={
1198 0x61, 0x00, 0x00, 0x00,
1199 0x00, 0x00, 0x11, 0x00, /* 0x110000 out of range */
1200 0xff, 0xff, 0x10, 0x00, /* 0x10FFFF in range */
1201 0x62, 0x00, 0x00, 0x00,
1202 0xff, 0xff, 0xff, 0xff, /* 0xffffffff out of range */
1203 0xff, 0xff, 0xff, 0x7f, /* 0x7fffffff out of range */
1204 0x62, 0x01, 0x00, 0x00,
1205 0x62, 0x02, 0x00, 0x00,
1206 };
1207
1208 static const uint16_t utf32Expected[]={
1209 0x0061,
1210 0xfffd, /* 0x110000 out of range */
1211 0xDBFF, /* 0x10FFFF in range */
1212 0xDFFF,
1213 0x0062,
1214 0xfffd, /* 0xffffffff out of range */
1215 0xfffd, /* 0x7fffffff out of range */
1216 0x0162,
1217 0x0262
1218 };
1219 static const int32_t utf32Offsets[]={
1220 0, 4, 8, 8, 12, 16, 20, 24, 28
1221 };
1222 static const uint8_t utf32ExpectedBack[]={
1223 0x61, 0x00, 0x00, 0x00,
1224 0xfd, 0xff, 0x00, 0x00, /* 0x110000 out of range */
1225 0xff, 0xff, 0x10, 0x00, /* 0x10FFFF in range */
1226 0x62, 0x00, 0x00, 0x00,
1227 0xfd, 0xff, 0x00, 0x00, /* 0xffffffff out of range */
1228 0xfd, 0xff, 0x00, 0x00, /* 0x7fffffff out of range */
1229 0x62, 0x01, 0x00, 0x00,
1230 0x62, 0x02, 0x00, 0x00
1231 };
1232 static const int32_t utf32OffsetsBack[]={
1233 0,0,0,0,
1234 1,1,1,1,
1235 2,2,2,2,
1236 4,4,4,4,
1237 5,5,5,5,
1238 6,6,6,6,
1239 7,7,7,7,
1240 8,8,8,8
1241 };
1242 testConvertToU(utf32, sizeof(utf32),
1243 utf32Expected, UPRV_LENGTHOF(utf32Expected), "utf-32le", utf32Offsets,FALSE );
1244 testConvertFromU(utf32Expected, UPRV_LENGTHOF(utf32Expected),
1245 utf32ExpectedBack, sizeof(utf32ExpectedBack), "utf-32le", utf32OffsetsBack, FALSE);
1246 }
1247 }
1248
1249 static void TestCoverageMBCS(){
1250 #if 0
1251 UErrorCode status = U_ZERO_ERROR;
1252 const char *directory = loadTestData(&status);
1253 char* tdpath = NULL;
1254 char* saveDirectory = (char*)malloc(sizeof(char) *(strlen(u_getDataDirectory())+1));
1255 int len = strlen(directory);
1256 char* index=NULL;
1257
1258 tdpath = (char*) malloc(sizeof(char) * (len * 2));
1259 uprv_strcpy(saveDirectory,u_getDataDirectory());
1260 log_verbose("Retrieved data directory %s \n",saveDirectory);
1261 uprv_strcpy(tdpath,directory);
1262 index=strrchr(tdpath,(char)U_FILE_SEP_CHAR);
1263
1264 if((unsigned int)(index-tdpath) != (strlen(tdpath)-1)){
1265 *(index+1)=0;
1266 }
1267 u_setDataDirectory(tdpath);
1268 log_verbose("ICU data directory is set to: %s \n" ,tdpath);
1269 #endif
1270
1271 /*some more test to increase the code coverage in MBCS. Create an test converter from test1.ucm
1272 which is test file for MBCS conversion with single-byte codepage data.*/
1273 {
1274
1275 /* MBCS with single byte codepage data test1.ucm*/
1276 const UChar unicodeInput[] = { 0x20ac, 0x0005, 0x0006, 0xdbc4, 0xde34, 0x0003};
1277 const uint8_t expectedtest1[] = { 0x00, 0x05, 0xff, 0x07, 0xff,};
1278 int32_t totest1Offs[] = { 0, 1, 2, 3, 5, };
1279
1280 /*from Unicode*/
1281 testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),
1282 expectedtest1, sizeof(expectedtest1), "@test1", totest1Offs,FALSE );
1283 }
1284
1285 /*some more test to increase the code coverage in MBCS. Create an test converter from test3.ucm
1286 which is test file for MBCS conversion with three-byte codepage data.*/
1287 {
1288
1289 /* MBCS with three byte codepage data test3.ucm*/
1290 const UChar unicodeInput[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0x000e};
1291 const uint8_t expectedtest3[] = { 0x00, 0x05, 0xff, 0x01, 0x02, 0x0b, 0x07, 0x01, 0x02, 0x0a, 0xff,};
1292 int32_t totest3Offs[] = { 0, 1, 2, 3, 3, 3, 4, 6, 6, 6, 8};
1293
1294 const uint8_t test3input[] = { 0x00, 0x05, 0x06, 0x01, 0x02, 0x0b, 0x07, 0x01, 0x02, 0x0a, 0x01, 0x02, 0x0c,};
1295 const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0xfffd};
1296 int32_t fromtest3Offs[] = { 0, 1, 2, 3, 6, 6, 7, 7, 10 };
1297
1298 /*from Unicode*/
1299 testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),
1300 expectedtest3, sizeof(expectedtest3), "@test3", totest3Offs,FALSE );
1301
1302 /*to Unicode*/
1303 testConvertToU(test3input, sizeof(test3input),
1304 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test3", fromtest3Offs ,FALSE);
1305
1306 }
1307
1308 /*some more test to increase the code coverage in MBCS. Create an test converter from test4.ucm
1309 which is test file for MBCS conversion with four-byte codepage data.*/
1310 {
1311
1312 /* MBCS with three byte codepage data test4.ucm*/
1313 static const UChar unicodeInput[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0x000e};
1314 static const uint8_t expectedtest4[] = { 0x00, 0x05, 0xff, 0x01, 0x02, 0x03, 0x0b, 0x07, 0x01, 0x02, 0x03, 0x0a, 0xff,};
1315 static const int32_t totest4Offs[] = { 0, 1, 2, 3, 3, 3, 3, 4, 6, 6, 6, 6, 8,};
1316
1317 static const uint8_t test4input[] = { 0x00, 0x05, 0x06, 0x01, 0x02, 0x03, 0x0b, 0x07, 0x01, 0x02, 0x03, 0x0a, 0x01, 0x02, 0x03, 0x0c,};
1318 static const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0xfffd};
1319 static const int32_t fromtest4Offs[] = { 0, 1, 2, 3, 7, 7, 8, 8, 12,};
1320
1321 /*from Unicode*/
1322 testConvertFromU(unicodeInput, UPRV_LENGTHOF(unicodeInput),
1323 expectedtest4, sizeof(expectedtest4), "@test4", totest4Offs,FALSE );
1324
1325 /*to Unicode*/
1326 testConvertToU(test4input, sizeof(test4input),
1327 expectedUnicode, UPRV_LENGTHOF(expectedUnicode), "@test4", fromtest4Offs,FALSE );
1328
1329 }
1330 #if 0
1331 free(tdpath);
1332 /* restore the original data directory */
1333 log_verbose("Setting the data directory to %s \n", saveDirectory);
1334 u_setDataDirectory(saveDirectory);
1335 free(saveDirectory);
1336 #endif
1337
1338 }
1339
1340 static void TestConverterType(const char *convName, UConverterType convType) {
1341 UConverter* myConverter;
1342 UErrorCode err = U_ZERO_ERROR;
1343
1344 myConverter = my_ucnv_open(convName, &err);
1345
1346 if (U_FAILURE(err)) {
1347 log_data_err("Failed to create an %s converter\n", convName);
1348 return;
1349 }
1350 else
1351 {
1352 if (ucnv_getType(myConverter)!=convType) {
1353 log_err("ucnv_getType Failed for %s. Got enum value 0x%X\n",
1354 convName, convType);
1355 }
1356 else {
1357 log_verbose("ucnv_getType %s ok\n", convName);
1358 }
1359 }
1360 ucnv_close(myConverter);
1361 }
1362
1363 static void TestConverterTypesAndStarters()
1364 {
1365 #if !UCONFIG_NO_LEGACY_CONVERSION
1366 UConverter* myConverter;
1367 UErrorCode err = U_ZERO_ERROR;
1368 UBool mystarters[256];
1369
1370 /* const UBool expectedKSCstarters[256] = {
1371 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1372 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1373 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1374 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1375 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1376 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1377 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1378 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1379 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1380 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1381 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1382 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1383 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1384 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
1385 FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1386 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1387 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1388 TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE,
1389 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1390 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1391 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1392 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1393 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1394 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1395 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
1396 TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};*/
1397
1398
1399 log_verbose("Testing KSC, ibm-930, ibm-878 for starters and their conversion types.");
1400
1401 myConverter = ucnv_open("ksc", &err);
1402 if (U_FAILURE(err)) {
1403 log_data_err("Failed to create an ibm-ksc converter\n");
1404 return;
1405 }
1406 else
1407 {
1408 if (ucnv_getType(myConverter)!=UCNV_MBCS)
1409 log_err("ucnv_getType Failed for ibm-949\n");
1410 else
1411 log_verbose("ucnv_getType ibm-949 ok\n");
1412
1413 if(myConverter!=NULL)
1414 ucnv_getStarters(myConverter, mystarters, &err);
1415
1416 /*if (memcmp(expectedKSCstarters, mystarters, sizeof(expectedKSCstarters)))
1417 log_err("Failed ucnv_getStarters for ksc\n");
1418 else
1419 log_verbose("ucnv_getStarters ok\n");*/
1420
1421 }
1422 ucnv_close(myConverter);
1423
1424 TestConverterType("ibm-930", UCNV_EBCDIC_STATEFUL);
1425 TestConverterType("ibm-878", UCNV_SBCS);
1426 #endif
1427
1428 TestConverterType("iso-8859-1", UCNV_LATIN_1);
1429
1430 TestConverterType("ibm-1208", UCNV_UTF8);
1431
1432 TestConverterType("utf-8", UCNV_UTF8);
1433 TestConverterType("UTF-16BE", UCNV_UTF16_BigEndian);
1434 TestConverterType("UTF-16LE", UCNV_UTF16_LittleEndian);
1435 TestConverterType("UTF-32BE", UCNV_UTF32_BigEndian);
1436 TestConverterType("UTF-32LE", UCNV_UTF32_LittleEndian);
1437
1438 #if !UCONFIG_NO_LEGACY_CONVERSION
1439
1440 #if defined(U_ENABLE_GENERIC_ISO_2022)
1441 TestConverterType("iso-2022", UCNV_ISO_2022);
1442 #endif
1443
1444 TestConverterType("hz", UCNV_HZ);
1445 #endif
1446
1447 TestConverterType("scsu", UCNV_SCSU);
1448
1449 #if !UCONFIG_NO_LEGACY_CONVERSION
1450 TestConverterType("x-iscii-de", UCNV_ISCII);
1451 #endif
1452
1453 TestConverterType("ascii", UCNV_US_ASCII);
1454 TestConverterType("utf-7", UCNV_UTF7);
1455 TestConverterType("IMAP-mailbox-name", UCNV_IMAP_MAILBOX);
1456 TestConverterType("bocu-1", UCNV_BOCU1);
1457 }
1458
1459 static void
1460 TestAmbiguousConverter(UConverter *cnv) {
1461 static const char inBytes[3]={ 0x61, 0x5B, 0x5c };
1462 UChar outUnicode[20]={ 0, 0, 0, 0 };
1463
1464 const char *s;
1465 UChar *u;
1466 UErrorCode errorCode;
1467 UBool isAmbiguous;
1468
1469 /* try to convert an 'a', a square bracket and a US-ASCII backslash */
1470 errorCode=U_ZERO_ERROR;
1471 s=inBytes;
1472 u=outUnicode;
1473 ucnv_toUnicode(cnv, &u, u+20, &s, s+3, NULL, TRUE, &errorCode);
1474 if(U_FAILURE(errorCode)) {
1475 /* we do not care about general failures in this test; the input may just not be mappable */
1476 return;
1477 }
1478
1479 if(outUnicode[0]!=0x61 || outUnicode[1]!=0x5B || outUnicode[2]==0xfffd) {
1480 /* not a close ASCII-family encoding, or 0x5c is unassigned/illegal: this test is not applicable */
1481 /* There are some encodings that are partially ASCII based,
1482 like the ISO-7 and GSM series of codepages, which we ignore. */
1483 return;
1484 }
1485
1486 isAmbiguous=ucnv_isAmbiguous(cnv);
1487
1488 /* check that outUnicode[1]!=0x5c is exactly the same as ucnv_isAmbiguous() */
1489 if((outUnicode[2]!=0x5c)!=isAmbiguous) {
1490 log_err("error: converter \"%s\" needs a backslash fix: %d but ucnv_isAmbiguous()==%d\n",
1491 ucnv_getName(cnv, &errorCode), outUnicode[2]!=0x5c, isAmbiguous);
1492 return;
1493 }
1494
1495 if(outUnicode[2]!=0x5c) {
1496 /* needs fixup, fix it */
1497 ucnv_fixFileSeparator(cnv, outUnicode, (int32_t)(u-outUnicode));
1498 if(outUnicode[2]!=0x5c) {
1499 /* the fix failed */
1500 log_err("error: ucnv_fixFileSeparator(%s) failed\n", ucnv_getName(cnv, &errorCode));
1501 return;
1502 }
1503 }
1504 }
1505
1506 static void TestAmbiguous()
1507 {
1508 UErrorCode status = U_ZERO_ERROR;
1509 UConverter *ascii_cnv = 0, *sjis_cnv = 0, *cnv;
1510 static const char target[] = {
1511 /* "\\usr\\local\\share\\data\\icutest.txt" */
1512 0x5c, 0x75, 0x73, 0x72,
1513 0x5c, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
1514 0x5c, 0x73, 0x68, 0x61, 0x72, 0x65,
1515 0x5c, 0x64, 0x61, 0x74, 0x61,
1516 0x5c, 0x69, 0x63, 0x75, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78, 0x74,
1517 0
1518 };
1519 UChar asciiResult[200], sjisResult[200];
1520 int32_t /*asciiLength = 0,*/ sjisLength = 0, i;
1521 const char *name;
1522
1523 /* enumerate all converters */
1524 status=U_ZERO_ERROR;
1525 for(i=0; (name=ucnv_getAvailableName(i))!=NULL; ++i) {
1526 cnv=ucnv_open(name, &status);
1527 if(U_SUCCESS(status)) {
1528 TestAmbiguousConverter(cnv);
1529 ucnv_close(cnv);
1530 } else {
1531 log_err("error: unable to open available converter \"%s\"\n", name);
1532 status=U_ZERO_ERROR;
1533 }
1534 }
1535
1536 #if !UCONFIG_NO_LEGACY_CONVERSION
1537 sjis_cnv = ucnv_open("ibm-943", &status);
1538 if (U_FAILURE(status))
1539 {
1540 log_data_err("Failed to create a SJIS converter\n");
1541 return;
1542 }
1543 ascii_cnv = ucnv_open("LATIN-1", &status);
1544 if (U_FAILURE(status))
1545 {
1546 log_data_err("Failed to create a LATIN-1 converter\n");
1547 ucnv_close(sjis_cnv);
1548 return;
1549 }
1550 /* convert target from SJIS to Unicode */
1551 sjisLength = ucnv_toUChars(sjis_cnv, sjisResult, UPRV_LENGTHOF(sjisResult), target, (int32_t)strlen(target), &status);
1552 if (U_FAILURE(status))
1553 {
1554 log_err("Failed to convert the SJIS string.\n");
1555 ucnv_close(sjis_cnv);
1556 ucnv_close(ascii_cnv);
1557 return;
1558 }
1559 /* convert target from Latin-1 to Unicode */
1560 /*asciiLength =*/ ucnv_toUChars(ascii_cnv, asciiResult, UPRV_LENGTHOF(asciiResult), target, (int32_t)strlen(target), &status);
1561 if (U_FAILURE(status))
1562 {
1563 log_err("Failed to convert the Latin-1 string.\n");
1564 ucnv_close(sjis_cnv);
1565 ucnv_close(ascii_cnv);
1566 return;
1567 }
1568 if (!ucnv_isAmbiguous(sjis_cnv))
1569 {
1570 log_err("SJIS converter should contain ambiguous character mappings.\n");
1571 ucnv_close(sjis_cnv);
1572 ucnv_close(ascii_cnv);
1573 return;
1574 }
1575 if (u_strcmp(sjisResult, asciiResult) == 0)
1576 {
1577 log_err("File separators for SJIS don't need to be fixed.\n");
1578 }
1579 ucnv_fixFileSeparator(sjis_cnv, sjisResult, sjisLength);
1580 if (u_strcmp(sjisResult, asciiResult) != 0)
1581 {
1582 log_err("Fixing file separator for SJIS failed.\n");
1583 }
1584 ucnv_close(sjis_cnv);
1585 ucnv_close(ascii_cnv);
1586 #endif
1587 }
1588
1589 static void
1590 TestSignatureDetection(){
1591 /* with null terminated strings */
1592 {
1593 static const char* data[] = {
1594 "\xFE\xFF\x00\x00", /* UTF-16BE */
1595 "\xFF\xFE\x00\x00", /* UTF-16LE */
1596 "\xEF\xBB\xBF\x00", /* UTF-8 */
1597 "\x0E\xFE\xFF\x00", /* SCSU */
1598
1599 "\xFE\xFF", /* UTF-16BE */
1600 "\xFF\xFE", /* UTF-16LE */
1601 "\xEF\xBB\xBF", /* UTF-8 */
1602 "\x0E\xFE\xFF", /* SCSU */
1603
1604 "\xFE\xFF\x41\x42", /* UTF-16BE */
1605 "\xFF\xFE\x41\x41", /* UTF-16LE */
1606 "\xEF\xBB\xBF\x41", /* UTF-8 */
1607 "\x0E\xFE\xFF\x41", /* SCSU */
1608
1609 "\x2B\x2F\x76\x38\x2D", /* UTF-7 */
1610 "\x2B\x2F\x76\x38\x41", /* UTF-7 */
1611 "\x2B\x2F\x76\x39\x41", /* UTF-7 */
1612 "\x2B\x2F\x76\x2B\x41", /* UTF-7 */
1613 "\x2B\x2F\x76\x2F\x41", /* UTF-7 */
1614
1615 "\xDD\x73\x66\x73" /* UTF-EBCDIC */
1616 };
1617 static const char* expected[] = {
1618 "UTF-16BE",
1619 "UTF-16LE",
1620 "UTF-8",
1621 "SCSU",
1622
1623 "UTF-16BE",
1624 "UTF-16LE",
1625 "UTF-8",
1626 "SCSU",
1627
1628 "UTF-16BE",
1629 "UTF-16LE",
1630 "UTF-8",
1631 "SCSU",
1632
1633 "UTF-7",
1634 "UTF-7",
1635 "UTF-7",
1636 "UTF-7",
1637 "UTF-7",
1638 "UTF-EBCDIC"
1639 };
1640 static const int32_t expectedLength[] ={
1641 2,
1642 2,
1643 3,
1644 3,
1645
1646 2,
1647 2,
1648 3,
1649 3,
1650
1651 2,
1652 2,
1653 3,
1654 3,
1655
1656 5,
1657 4,
1658 4,
1659 4,
1660 4,
1661 4
1662 };
1663 int i=0;
1664 UErrorCode err;
1665 int32_t signatureLength = -1;
1666 const char* source = NULL;
1667 const char* enc = NULL;
1668 for( ; i<UPRV_LENGTHOF(data); i++){
1669 err = U_ZERO_ERROR;
1670 source = data[i];
1671 enc = ucnv_detectUnicodeSignature(source, -1 , &signatureLength, &err);
1672 if(U_FAILURE(err)){
1673 log_err("ucnv_detectUnicodeSignature failed for source : %s at index :%i. Error: %s\n", source,i,u_errorName(err));
1674 continue;
1675 }
1676 if(enc == NULL || strcmp(enc,expected[i]) !=0){
1677 log_err("ucnv_detectUnicodeSignature failed for source : %s at index :%i. Expected: %s. Got: %s\n",source,i,expected[i],enc);
1678 continue;
1679 }
1680 if(signatureLength != expectedLength[i]){
1681 log_err("ucnv_detectUnicodeSignature failed for source : %s at index :%i.Expected Length: %i. Got length: %i\n",source,i,signatureLength,expectedLength[i]);
1682 }
1683 }
1684 }
1685 {
1686 static const char* data[] = {
1687 "\xFE\xFF\x00", /* UTF-16BE */
1688 "\xFF\xFE\x00", /* UTF-16LE */
1689 "\xEF\xBB\xBF\x00", /* UTF-8 */
1690 "\x0E\xFE\xFF\x00", /* SCSU */
1691 "\x00\x00\xFE\xFF", /* UTF-32BE */
1692 "\xFF\xFE\x00\x00", /* UTF-32LE */
1693 "\xFE\xFF", /* UTF-16BE */
1694 "\xFF\xFE", /* UTF-16LE */
1695 "\xEF\xBB\xBF", /* UTF-8 */
1696 "\x0E\xFE\xFF", /* SCSU */
1697 "\x00\x00\xFE\xFF", /* UTF-32BE */
1698 "\xFF\xFE\x00\x00", /* UTF-32LE */
1699 "\xFE\xFF\x41\x42", /* UTF-16BE */
1700 "\xFF\xFE\x41\x41", /* UTF-16LE */
1701 "\xEF\xBB\xBF\x41", /* UTF-8 */
1702 "\x0E\xFE\xFF\x41", /* SCSU */
1703 "\x00\x00\xFE\xFF\x41", /* UTF-32BE */
1704 "\xFF\xFE\x00\x00\x42", /* UTF-32LE */
1705 "\xFB\xEE\x28", /* BOCU-1 */
1706 "\xFF\x41\x42" /* NULL */
1707 };
1708 static const int len[] = {
1709 3,
1710 3,
1711 4,
1712 4,
1713 4,
1714 4,
1715 2,
1716 2,
1717 3,
1718 3,
1719 4,
1720 4,
1721 4,
1722 4,
1723 4,
1724 4,
1725 5,
1726 5,
1727 3,
1728 3
1729 };
1730
1731 static const char* expected[] = {
1732 "UTF-16BE",
1733 "UTF-16LE",
1734 "UTF-8",
1735 "SCSU",
1736 "UTF-32BE",
1737 "UTF-32LE",
1738 "UTF-16BE",
1739 "UTF-16LE",
1740 "UTF-8",
1741 "SCSU",
1742 "UTF-32BE",
1743 "UTF-32LE",
1744 "UTF-16BE",
1745 "UTF-16LE",
1746 "UTF-8",
1747 "SCSU",
1748 "UTF-32BE",
1749 "UTF-32LE",
1750 "BOCU-1",
1751 NULL
1752 };
1753 static const int32_t expectedLength[] ={
1754 2,
1755 2,
1756 3,
1757 3,
1758 4,
1759 4,
1760 2,
1761 2,
1762 3,
1763 3,
1764 4,
1765 4,
1766 2,
1767 2,
1768 3,
1769 3,
1770 4,
1771 4,
1772 3,
1773 0
1774 };
1775 int i=0;
1776 UErrorCode err;
1777 int32_t signatureLength = -1;
1778 int32_t sourceLength=-1;
1779 const char* source = NULL;
1780 const char* enc = NULL;
1781 for( ; i<UPRV_LENGTHOF(data); i++){
1782 err = U_ZERO_ERROR;
1783 source = data[i];
1784 sourceLength = len[i];
1785 enc = ucnv_detectUnicodeSignature(source, sourceLength , &signatureLength, &err);
1786 if(U_FAILURE(err)){
1787 log_err("ucnv_detectUnicodeSignature test2 failed for source : %s at index :%i. Error: %s\n", source,i,u_errorName(err));
1788 continue;
1789 }
1790 if(enc == NULL || strcmp(enc,expected[i]) !=0){
1791 if(expected[i] !=NULL){
1792 log_err("ucnv_detectUnicodeSignature test2 failed for source : %s at index :%i. Expected: %s. Got: %s\n",source,i,expected[i],enc);
1793 continue;
1794 }
1795 }
1796 if(signatureLength != expectedLength[i]){
1797 log_err("ucnv_detectUnicodeSignature test2 failed for source : %s at index :%i.Expected Length: %i. Got length: %i\n",source,i,signatureLength,expectedLength[i]);
1798 }
1799 }
1800 }
1801 }
1802
1803 static void TestUTF7() {
1804 /* test input */
1805 static const uint8_t in[]={
1806 /* H - +Jjo- - ! +- +2AHcAQ */
1807 0x48,
1808 0x2d,
1809 0x2b, 0x4a, 0x6a, 0x6f,
1810 0x2d, 0x2d,
1811 0x21,
1812 0x2b, 0x2d,
1813 0x2b, 0x32, 0x41, 0x48, 0x63, 0x41, 0x51
1814 };
1815
1816 /* expected test results */
1817 static const int32_t results[]={
1818 /* number of bytes read, code point */
1819 1, 0x48,
1820 1, 0x2d,
1821 4, 0x263a, /* <WHITE SMILING FACE> */
1822 2, 0x2d,
1823 1, 0x21,
1824 2, 0x2b,
1825 7, 0x10401
1826 };
1827
1828 const char *cnvName;
1829 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
1830 UErrorCode errorCode=U_ZERO_ERROR;
1831 UConverter *cnv=ucnv_open("UTF-7", &errorCode);
1832 if(U_FAILURE(errorCode)) {
1833 log_data_err("Unable to open a UTF-7 converter: %s\n", u_errorName(errorCode));
1834 return;
1835 }
1836 TestNextUChar(cnv, source, limit, results, "UTF-7");
1837 /* Test the condition when source >= sourceLimit */
1838 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
1839 cnvName = ucnv_getName(cnv, &errorCode);
1840 if (U_FAILURE(errorCode) || uprv_strcmp(cnvName, "UTF-7") != 0) {
1841 log_err("UTF-7 converter is called %s: %s\n", cnvName, u_errorName(errorCode));
1842 }
1843 ucnv_close(cnv);
1844 }
1845
1846 static void TestIMAP() {
1847 /* test input */
1848 static const uint8_t in[]={
1849 /* H - &Jjo- - ! &- &2AHcAQ- \ */
1850 0x48,
1851 0x2d,
1852 0x26, 0x4a, 0x6a, 0x6f,
1853 0x2d, 0x2d,
1854 0x21,
1855 0x26, 0x2d,
1856 0x26, 0x32, 0x41, 0x48, 0x63, 0x41, 0x51, 0x2d
1857 };
1858
1859 /* expected test results */
1860 static const int32_t results[]={
1861 /* number of bytes read, code point */
1862 1, 0x48,
1863 1, 0x2d,
1864 4, 0x263a, /* <WHITE SMILING FACE> */
1865 2, 0x2d,
1866 1, 0x21,
1867 2, 0x26,
1868 7, 0x10401
1869 };
1870
1871 const char *cnvName;
1872 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
1873 UErrorCode errorCode=U_ZERO_ERROR;
1874 UConverter *cnv=ucnv_open("IMAP-mailbox-name", &errorCode);
1875 if(U_FAILURE(errorCode)) {
1876 log_data_err("Unable to open a IMAP-mailbox-name converter: %s\n", u_errorName(errorCode));
1877 return;
1878 }
1879 TestNextUChar(cnv, source, limit, results, "IMAP-mailbox-name");
1880 /* Test the condition when source >= sourceLimit */
1881 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
1882 cnvName = ucnv_getName(cnv, &errorCode);
1883 if (U_FAILURE(errorCode) || uprv_strcmp(cnvName, "IMAP-mailbox-name") != 0) {
1884 log_err("IMAP-mailbox-name converter is called %s: %s\n", cnvName, u_errorName(errorCode));
1885 }
1886 ucnv_close(cnv);
1887 }
1888
1889 static void TestUTF8() {
1890 /* test input */
1891 static const uint8_t in[]={
1892 0x61,
1893 0xc2, 0x80,
1894 0xe0, 0xa0, 0x80,
1895 0xf0, 0x90, 0x80, 0x80,
1896 0xf4, 0x84, 0x8c, 0xa1,
1897 0xf0, 0x90, 0x90, 0x81
1898 };
1899
1900 /* expected test results */
1901 static const int32_t results[]={
1902 /* number of bytes read, code point */
1903 1, 0x61,
1904 2, 0x80,
1905 3, 0x800,
1906 4, 0x10000,
1907 4, 0x104321,
1908 4, 0x10401
1909 };
1910
1911 /* error test input */
1912 static const uint8_t in2[]={
1913 0x61,
1914 0xc0, 0x80, /* illegal non-shortest form */
1915 0xe0, 0x80, 0x80, /* illegal non-shortest form */
1916 0xf0, 0x80, 0x80, 0x80, /* illegal non-shortest form */
1917 0xc0, 0xc0, /* illegal trail byte */
1918 0xf4, 0x90, 0x80, 0x80, /* 0x110000 out of range */
1919 0xf8, 0x80, 0x80, 0x80, 0x80, /* too long */
1920 0xfe, /* illegal byte altogether */
1921 0x62
1922 };
1923
1924 /* expected error test results */
1925 static const int32_t results2[]={
1926 /* number of bytes read, code point */
1927 1, 0x61,
1928 22, 0x62
1929 };
1930
1931 UConverterToUCallback cb;
1932 const void *p;
1933
1934 const char *source=(const char *)in,*limit=(const char *)in+sizeof(in);
1935 UErrorCode errorCode=U_ZERO_ERROR;
1936 UConverter *cnv=ucnv_open("UTF-8", &errorCode);
1937 if(U_FAILURE(errorCode)) {
1938 log_err("Unable to open a UTF-8 converter: %s\n", u_errorName(errorCode));
1939 return;
1940 }
1941 TestNextUChar(cnv, source, limit, results, "UTF-8");
1942 /* Test the condition when source >= sourceLimit */
1943 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
1944
1945 /* test error behavior with a skip callback */
1946 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_SKIP, NULL, &cb, &p, &errorCode);
1947 source=(const char *)in2;
1948 limit=(const char *)(in2+sizeof(in2));
1949 TestNextUChar(cnv, source, limit, results2, "UTF-8");
1950
1951 ucnv_close(cnv);
1952 }
1953
1954 static void TestCESU8() {
1955 /* test input */
1956 static const uint8_t in[]={
1957 0x61,
1958 0xc2, 0x80,
1959 0xe0, 0xa0, 0x80,
1960 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80,
1961 0xed, 0xb0, 0x81, 0xed, 0xa0, 0x82,
1962 0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf,
1963 0xef, 0xbf, 0xbc
1964 };
1965
1966 /* expected test results */
1967 static const int32_t results[]={
1968 /* number of bytes read, code point */
1969 1, 0x61,
1970 2, 0x80,
1971 3, 0x800,
1972 6, 0x10000,
1973 3, 0xdc01,
1974 -1,0xd802, /* may read 3 or 6 bytes */
1975 -1,0x10ffff,/* may read 0 or 3 bytes */
1976 3, 0xfffc
1977 };
1978
1979 /* error test input */
1980 static const uint8_t in2[]={
1981 0x61,
1982 0xc0, 0x80, /* illegal non-shortest form */
1983 0xe0, 0x80, 0x80, /* illegal non-shortest form */
1984 0xf0, 0x80, 0x80, 0x80, /* illegal non-shortest form */
1985 0xc0, 0xc0, /* illegal trail byte */
1986 0xf0, 0x90, 0x80, 0x80, /* illegal 4-byte supplementary code point */
1987 0xf4, 0x84, 0x8c, 0xa1, /* illegal 4-byte supplementary code point */
1988 0xf0, 0x90, 0x90, 0x81, /* illegal 4-byte supplementary code point */
1989 0xf4, 0x90, 0x80, 0x80, /* 0x110000 out of range */
1990 0xf8, 0x80, 0x80, 0x80, 0x80, /* too long */
1991 0xfe, /* illegal byte altogether */
1992 0x62
1993 };
1994
1995 /* expected error test results */
1996 static const int32_t results2[]={
1997 /* number of bytes read, code point */
1998 1, 0x61,
1999 34, 0x62
2000 };
2001
2002 UConverterToUCallback cb;
2003 const void *p;
2004
2005 const char *source=(const char *)in,*limit=(const char *)in+sizeof(in);
2006 UErrorCode errorCode=U_ZERO_ERROR;
2007 UConverter *cnv=ucnv_open("CESU-8", &errorCode);
2008 if(U_FAILURE(errorCode)) {
2009 log_data_err("Unable to open a CESU-8 converter: %s\n", u_errorName(errorCode));
2010 return;
2011 }
2012 TestNextUChar(cnv, source, limit, results, "CESU-8");
2013 /* Test the condition when source >= sourceLimit */
2014 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2015
2016 /* test error behavior with a skip callback */
2017 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_SKIP, NULL, &cb, &p, &errorCode);
2018 source=(const char *)in2;
2019 limit=(const char *)(in2+sizeof(in2));
2020 TestNextUChar(cnv, source, limit, results2, "CESU-8");
2021
2022 ucnv_close(cnv);
2023 }
2024
2025 static void TestUTF16() {
2026 /* test input */
2027 static const uint8_t in1[]={
2028 0xfe, 0xff, 0x4e, 0x00, 0xfe, 0xff
2029 };
2030 static const uint8_t in2[]={
2031 0xff, 0xfe, 0x4e, 0x00, 0xfe, 0xff
2032 };
2033 static const uint8_t in3[]={
2034 0xfe, 0xfe, 0x4e, 0x00, 0xfe, 0xff, 0xd8, 0x40, 0xdc, 0x01
2035 };
2036
2037 /* expected test results */
2038 static const int32_t results1[]={
2039 /* number of bytes read, code point */
2040 4, 0x4e00,
2041 2, 0xfeff
2042 };
2043 static const int32_t results2[]={
2044 /* number of bytes read, code point */
2045 4, 0x004e,
2046 2, 0xfffe
2047 };
2048 static const int32_t results3[]={
2049 /* number of bytes read, code point */
2050 2, 0xfefe,
2051 2, 0x4e00,
2052 2, 0xfeff,
2053 4, 0x20001
2054 };
2055
2056 const char *source, *limit;
2057
2058 UErrorCode errorCode=U_ZERO_ERROR;
2059 UConverter *cnv=ucnv_open("UTF-16", &errorCode);
2060 if(U_FAILURE(errorCode)) {
2061 log_err("Unable to open a UTF-16 converter: %s\n", u_errorName(errorCode));
2062 return;
2063 }
2064
2065 source=(const char *)in1, limit=(const char *)in1+sizeof(in1);
2066 TestNextUChar(cnv, source, limit, results1, "UTF-16");
2067
2068 source=(const char *)in2, limit=(const char *)in2+sizeof(in2);
2069 ucnv_resetToUnicode(cnv);
2070 TestNextUChar(cnv, source, limit, results2, "UTF-16");
2071
2072 source=(const char *)in3, limit=(const char *)in3+sizeof(in3);
2073 ucnv_resetToUnicode(cnv);
2074 TestNextUChar(cnv, source, limit, results3, "UTF-16");
2075
2076 /* Test the condition when source >= sourceLimit */
2077 ucnv_resetToUnicode(cnv);
2078 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2079
2080 ucnv_close(cnv);
2081 }
2082
2083 static void TestUTF16BE() {
2084 /* test input */
2085 static const uint8_t in[]={
2086 0x00, 0x61,
2087 0x00, 0xc0,
2088 0x00, 0x31,
2089 0x00, 0xf4,
2090 0xce, 0xfe,
2091 0xd8, 0x01, 0xdc, 0x01
2092 };
2093
2094 /* expected test results */
2095 static const int32_t results[]={
2096 /* number of bytes read, code point */
2097 2, 0x61,
2098 2, 0xc0,
2099 2, 0x31,
2100 2, 0xf4,
2101 2, 0xcefe,
2102 4, 0x10401
2103 };
2104
2105 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2106 UErrorCode errorCode=U_ZERO_ERROR;
2107 UConverter *cnv=ucnv_open("utf-16be", &errorCode);
2108 if(U_FAILURE(errorCode)) {
2109 log_err("Unable to open a UTF16-BE converter: %s\n", u_errorName(errorCode));
2110 return;
2111 }
2112 TestNextUChar(cnv, source, limit, results, "UTF-16BE");
2113 /* Test the condition when source >= sourceLimit */
2114 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2115 /*Test for the condition where there is an invalid character*/
2116 {
2117 static const uint8_t source2[]={0x61};
2118 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
2119 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_TRUNCATED_CHAR_FOUND, "an invalid character");
2120 }
2121 #if 0
2122 /*
2123 * Test disabled because currently the UTF-16BE/LE converters are supposed
2124 * to not set errors for unpaired surrogates.
2125 * This may change with
2126 * Jitterbug 1838 - forbid converting surrogate code points in UTF-16/32
2127 */
2128
2129 /*Test for the condition where there is a surrogate pair*/
2130 {
2131 const uint8_t source2[]={0xd8, 0x01};
2132 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_TRUNCATED_CHAR_FOUND, "an truncated surrogate character");
2133 }
2134 #endif
2135 ucnv_close(cnv);
2136 }
2137
2138 static void
2139 TestUTF16LE() {
2140 /* test input */
2141 static const uint8_t in[]={
2142 0x61, 0x00,
2143 0x31, 0x00,
2144 0x4e, 0x2e,
2145 0x4e, 0x00,
2146 0x01, 0xd8, 0x01, 0xdc
2147 };
2148
2149 /* expected test results */
2150 static const int32_t results[]={
2151 /* number of bytes read, code point */
2152 2, 0x61,
2153 2, 0x31,
2154 2, 0x2e4e,
2155 2, 0x4e,
2156 4, 0x10401
2157 };
2158
2159 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2160 UErrorCode errorCode=U_ZERO_ERROR;
2161 UConverter *cnv=ucnv_open("utf-16le", &errorCode);
2162 if(U_FAILURE(errorCode)) {
2163 log_err("Unable to open a UTF16-LE converter: %s\n", u_errorName(errorCode));
2164 return;
2165 }
2166 TestNextUChar(cnv, source, limit, results, "UTF-16LE");
2167 /* Test the condition when source >= sourceLimit */
2168 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2169 /*Test for the condition where there is an invalid character*/
2170 {
2171 static const uint8_t source2[]={0x61};
2172 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
2173 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_TRUNCATED_CHAR_FOUND, "an invalid character");
2174 }
2175 #if 0
2176 /*
2177 * Test disabled because currently the UTF-16BE/LE converters are supposed
2178 * to not set errors for unpaired surrogates.
2179 * This may change with
2180 * Jitterbug 1838 - forbid converting surrogate code points in UTF-16/32
2181 */
2182
2183 /*Test for the condition where there is a surrogate character*/
2184 {
2185 static const uint8_t source2[]={0x01, 0xd8};
2186 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_TRUNCATED_CHAR_FOUND, "an truncated surrogate character");
2187 }
2188 #endif
2189
2190 ucnv_close(cnv);
2191 }
2192
2193 static void TestUTF32() {
2194 /* test input */
2195 static const uint8_t in1[]={
2196 0x00, 0x00, 0xfe, 0xff, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0xfe, 0xff
2197 };
2198 static const uint8_t in2[]={
2199 0xff, 0xfe, 0x00, 0x00, 0x00, 0x10, 0x0f, 0x00, 0xfe, 0xff, 0x00, 0x00
2200 };
2201 static const uint8_t in3[]={
2202 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0xd8, 0x40, 0x00, 0x00, 0xdc, 0x01
2203 };
2204
2205 /* expected test results */
2206 static const int32_t results1[]={
2207 /* number of bytes read, code point */
2208 8, 0x100f00,
2209 4, 0xfeff
2210 };
2211 static const int32_t results2[]={
2212 /* number of bytes read, code point */
2213 8, 0x0f1000,
2214 4, 0xfffe
2215 };
2216 static const int32_t results3[]={
2217 /* number of bytes read, code point */
2218 4, 0xfefe,
2219 4, 0x100f00,
2220 4, 0xfffd, /* unmatched surrogate */
2221 4, 0xfffd /* unmatched surrogate */
2222 };
2223
2224 const char *source, *limit;
2225
2226 UErrorCode errorCode=U_ZERO_ERROR;
2227 UConverter *cnv=ucnv_open("UTF-32", &errorCode);
2228 if(U_FAILURE(errorCode)) {
2229 log_data_err("Unable to open a UTF-32 converter: %s\n", u_errorName(errorCode));
2230 return;
2231 }
2232
2233 source=(const char *)in1, limit=(const char *)in1+sizeof(in1);
2234 TestNextUChar(cnv, source, limit, results1, "UTF-32");
2235
2236 source=(const char *)in2, limit=(const char *)in2+sizeof(in2);
2237 ucnv_resetToUnicode(cnv);
2238 TestNextUChar(cnv, source, limit, results2, "UTF-32");
2239
2240 source=(const char *)in3, limit=(const char *)in3+sizeof(in3);
2241 ucnv_resetToUnicode(cnv);
2242 TestNextUChar(cnv, source, limit, results3, "UTF-32");
2243
2244 /* Test the condition when source >= sourceLimit */
2245 ucnv_resetToUnicode(cnv);
2246 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2247
2248 ucnv_close(cnv);
2249 }
2250
2251 static void
2252 TestUTF32BE() {
2253 /* test input */
2254 static const uint8_t in[]={
2255 0x00, 0x00, 0x00, 0x61,
2256 0x00, 0x00, 0x30, 0x61,
2257 0x00, 0x00, 0xdc, 0x00,
2258 0x00, 0x00, 0xd8, 0x00,
2259 0x00, 0x00, 0xdf, 0xff,
2260 0x00, 0x00, 0xff, 0xfe,
2261 0x00, 0x10, 0xab, 0xcd,
2262 0x00, 0x10, 0xff, 0xff
2263 };
2264
2265 /* expected test results */
2266 static const int32_t results[]={
2267 /* number of bytes read, code point */
2268 4, 0x61,
2269 4, 0x3061,
2270 4, 0xfffd,
2271 4, 0xfffd,
2272 4, 0xfffd,
2273 4, 0xfffe,
2274 4, 0x10abcd,
2275 4, 0x10ffff
2276 };
2277
2278 /* error test input */
2279 static const uint8_t in2[]={
2280 0x00, 0x00, 0x00, 0x61,
2281 0x00, 0x11, 0x00, 0x00, /* 0x110000 out of range */
2282 0x00, 0x00, 0x00, 0x62,
2283 0xff, 0xff, 0xff, 0xff, /* 0xffffffff out of range */
2284 0x7f, 0xff, 0xff, 0xff, /* 0x7fffffff out of range */
2285 0x00, 0x00, 0x01, 0x62,
2286 0x00, 0x00, 0x02, 0x62
2287 };
2288
2289 /* expected error test results */
2290 static const int32_t results2[]={
2291 /* number of bytes read, code point */
2292 4, 0x61,
2293 8, 0x62,
2294 12, 0x162,
2295 4, 0x262
2296 };
2297
2298 UConverterToUCallback cb;
2299 const void *p;
2300
2301 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2302 UErrorCode errorCode=U_ZERO_ERROR;
2303 UConverter *cnv=ucnv_open("UTF-32BE", &errorCode);
2304 if(U_FAILURE(errorCode)) {
2305 log_data_err("Unable to open a UTF-32BE converter: %s\n", u_errorName(errorCode));
2306 return;
2307 }
2308 TestNextUChar(cnv, source, limit, results, "UTF-32BE");
2309
2310 /* Test the condition when source >= sourceLimit */
2311 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2312
2313 /* test error behavior with a skip callback */
2314 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_SKIP, NULL, &cb, &p, &errorCode);
2315 source=(const char *)in2;
2316 limit=(const char *)(in2+sizeof(in2));
2317 TestNextUChar(cnv, source, limit, results2, "UTF-32BE");
2318
2319 ucnv_close(cnv);
2320 }
2321
2322 static void
2323 TestUTF32LE() {
2324 /* test input */
2325 static const uint8_t in[]={
2326 0x61, 0x00, 0x00, 0x00,
2327 0x61, 0x30, 0x00, 0x00,
2328 0x00, 0xdc, 0x00, 0x00,
2329 0x00, 0xd8, 0x00, 0x00,
2330 0xff, 0xdf, 0x00, 0x00,
2331 0xfe, 0xff, 0x00, 0x00,
2332 0xcd, 0xab, 0x10, 0x00,
2333 0xff, 0xff, 0x10, 0x00
2334 };
2335
2336 /* expected test results */
2337 static const int32_t results[]={
2338 /* number of bytes read, code point */
2339 4, 0x61,
2340 4, 0x3061,
2341 4, 0xfffd,
2342 4, 0xfffd,
2343 4, 0xfffd,
2344 4, 0xfffe,
2345 4, 0x10abcd,
2346 4, 0x10ffff
2347 };
2348
2349 /* error test input */
2350 static const uint8_t in2[]={
2351 0x61, 0x00, 0x00, 0x00,
2352 0x00, 0x00, 0x11, 0x00, /* 0x110000 out of range */
2353 0x62, 0x00, 0x00, 0x00,
2354 0xff, 0xff, 0xff, 0xff, /* 0xffffffff out of range */
2355 0xff, 0xff, 0xff, 0x7f, /* 0x7fffffff out of range */
2356 0x62, 0x01, 0x00, 0x00,
2357 0x62, 0x02, 0x00, 0x00,
2358 };
2359
2360 /* expected error test results */
2361 static const int32_t results2[]={
2362 /* number of bytes read, code point */
2363 4, 0x61,
2364 8, 0x62,
2365 12, 0x162,
2366 4, 0x262,
2367 };
2368
2369 UConverterToUCallback cb;
2370 const void *p;
2371
2372 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2373 UErrorCode errorCode=U_ZERO_ERROR;
2374 UConverter *cnv=ucnv_open("UTF-32LE", &errorCode);
2375 if(U_FAILURE(errorCode)) {
2376 log_data_err("Unable to open a UTF-32LE converter: %s\n", u_errorName(errorCode));
2377 return;
2378 }
2379 TestNextUChar(cnv, source, limit, results, "UTF-32LE");
2380
2381 /* Test the condition when source >= sourceLimit */
2382 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2383
2384 /* test error behavior with a skip callback */
2385 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_SKIP, NULL, &cb, &p, &errorCode);
2386 source=(const char *)in2;
2387 limit=(const char *)(in2+sizeof(in2));
2388 TestNextUChar(cnv, source, limit, results2, "UTF-32LE");
2389
2390 ucnv_close(cnv);
2391 }
2392
2393 static void
2394 TestLATIN1() {
2395 /* test input */
2396 static const uint8_t in[]={
2397 0x61,
2398 0x31,
2399 0x32,
2400 0xc0,
2401 0xf0,
2402 0xf4,
2403 };
2404
2405 /* expected test results */
2406 static const int32_t results[]={
2407 /* number of bytes read, code point */
2408 1, 0x61,
2409 1, 0x31,
2410 1, 0x32,
2411 1, 0xc0,
2412 1, 0xf0,
2413 1, 0xf4,
2414 };
2415 static const uint16_t in1[] = {
2416 0x08, 0x00, 0x1b, 0x4c, 0xea, 0x16, 0xca, 0xd3, 0x94, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84,
2417 0xc4, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84, 0xc4, 0x16, 0xca, 0xd3, 0x94, 0x08, 0x02, 0x0f,
2418 0x53, 0x4a, 0x4e, 0x16, 0x7d, 0x00, 0x30, 0x82, 0x52, 0x4d, 0x30, 0x6b, 0x6d, 0x41, 0x88, 0x4c,
2419 0xe5, 0x97, 0x9f, 0x08, 0x0c, 0x16, 0xca, 0xd3, 0x94, 0x15, 0xae, 0x0e, 0x6b, 0x4c, 0x08, 0x0d,
2420 0x8c, 0xb4, 0xa3, 0x9f, 0xca, 0x99, 0xcb, 0x8b, 0xc2, 0x97, 0xcc, 0xaa, 0x84, 0x08, 0x02, 0x0e,
2421 0x7c, 0x73, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x93, 0xd3, 0xb4, 0xc5, 0xdc, 0x9f, 0x0e, 0x79, 0x3e,
2422 0x06, 0xae, 0xb1, 0x9d, 0x93, 0xd3, 0x08, 0x0c, 0xbe, 0xa3, 0x8f, 0x08, 0x88, 0xbe, 0xa3, 0x8d,
2423 0xd3, 0xa8, 0xa3, 0x97, 0xc5, 0x17, 0x89, 0x08, 0x0d, 0x15, 0xd2, 0x08, 0x01, 0x93, 0xc8, 0xaa,
2424 0x8f, 0x0e, 0x61, 0x1b, 0x99, 0xcb, 0x0e, 0x4e, 0xba, 0x9f, 0xa1, 0xae, 0x93, 0xa8, 0xa0, 0x08,
2425 0x02, 0x08, 0x0c, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x0f, 0x4f, 0xe1, 0x80, 0x05, 0xec, 0x60, 0x8d,
2426 0xea, 0x06, 0xd3, 0xe6, 0x0f, 0x8a, 0x00, 0x30, 0x44, 0x65, 0xb9, 0xe4, 0xfe, 0xe7, 0xc2, 0x06,
2427 0xcb, 0x82
2428 };
2429 static const uint8_t out1[] = {
2430 0x08, 0x00, 0x1b, 0x4c, 0xea, 0x16, 0xca, 0xd3, 0x94, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84,
2431 0xc4, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84, 0xc4, 0x16, 0xca, 0xd3, 0x94, 0x08, 0x02, 0x0f,
2432 0x53, 0x4a, 0x4e, 0x16, 0x7d, 0x00, 0x30, 0x82, 0x52, 0x4d, 0x30, 0x6b, 0x6d, 0x41, 0x88, 0x4c,
2433 0xe5, 0x97, 0x9f, 0x08, 0x0c, 0x16, 0xca, 0xd3, 0x94, 0x15, 0xae, 0x0e, 0x6b, 0x4c, 0x08, 0x0d,
2434 0x8c, 0xb4, 0xa3, 0x9f, 0xca, 0x99, 0xcb, 0x8b, 0xc2, 0x97, 0xcc, 0xaa, 0x84, 0x08, 0x02, 0x0e,
2435 0x7c, 0x73, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x93, 0xd3, 0xb4, 0xc5, 0xdc, 0x9f, 0x0e, 0x79, 0x3e,
2436 0x06, 0xae, 0xb1, 0x9d, 0x93, 0xd3, 0x08, 0x0c, 0xbe, 0xa3, 0x8f, 0x08, 0x88, 0xbe, 0xa3, 0x8d,
2437 0xd3, 0xa8, 0xa3, 0x97, 0xc5, 0x17, 0x89, 0x08, 0x0d, 0x15, 0xd2, 0x08, 0x01, 0x93, 0xc8, 0xaa,
2438 0x8f, 0x0e, 0x61, 0x1b, 0x99, 0xcb, 0x0e, 0x4e, 0xba, 0x9f, 0xa1, 0xae, 0x93, 0xa8, 0xa0, 0x08,
2439 0x02, 0x08, 0x0c, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x0f, 0x4f, 0xe1, 0x80, 0x05, 0xec, 0x60, 0x8d,
2440 0xea, 0x06, 0xd3, 0xe6, 0x0f, 0x8a, 0x00, 0x30, 0x44, 0x65, 0xb9, 0xe4, 0xfe, 0xe7, 0xc2, 0x06,
2441 0xcb, 0x82
2442 };
2443 static const uint16_t in2[]={
2444 0x1B, 0x24, 0x29, 0x47, 0x0E, 0x23, 0x21, 0x23, 0x22, 0x23,
2445 0x23, 0x23, 0x24, 0x23, 0x25, 0x23, 0x26, 0x23, 0x27, 0x23,
2446 0x28, 0x23, 0x29, 0x23, 0x2A, 0x23, 0x2B, 0x0F, 0x2F, 0x2A,
2447 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20, 0x31, 0x20, 0x2A, 0x2F,
2448 0x0D, 0x0A, 0x1B, 0x24, 0x2A, 0x48, 0x1B, 0x4E, 0x22, 0x21,
2449 0x1B, 0x4E, 0x22, 0x22, 0x1B, 0x4E, 0x22, 0x23, 0x1B, 0x4E,
2450 0x22, 0x24, 0x1B, 0x4E, 0x22, 0x25, 0x0F, 0x2F, 0x2A, 0x70,
2451 0x6C, 0x61, 0x6E, 0x65, 0x32, 0x2A, 0x2F, 0x20, 0x0D, 0x0A,
2452 0x1B, 0x24, 0x2B, 0x49, 0x1B, 0x4F, 0x22, 0x44, 0x1B, 0x4F,
2453 0x22, 0x45, 0x1B, 0x4F, 0x22, 0x46, 0x1B, 0x4F, 0x22, 0x47,
2454 0x1B, 0x4F, 0x22, 0x48, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61,
2455 0x6E, 0x65, 0x20, 0x33, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B,
2456 0x24, 0x2B, 0x4A, 0x1B, 0x4F, 0x21, 0x44, 0x1B, 0x4F, 0x21,
2457 0x45, 0x1B, 0x4F, 0x22, 0x6A, 0x1B, 0x4F, 0x22, 0x6B, 0x1B,
2458 0x4F, 0x22, 0x6C, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
2459 0x65, 0x20, 0x34, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
2460 0x2B, 0x4B, 0x1B, 0x4F, 0x21, 0x74, 0x1B, 0x4F, 0x22, 0x50,
2461 0x1B, 0x4F, 0x22, 0x51, 0x1B, 0x4F, 0x23, 0x37, 0x1B, 0x4F,
2462 0x22, 0x5C, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
2463 0x65, 0x20, 0x35, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
2464 0x2B, 0x4C, 0x1B, 0x4F, 0x21, 0x23, 0x1B, 0x4F, 0x22, 0x2C,
2465 0x1B, 0x4F, 0x23, 0x4E, 0x1B, 0x4F, 0x21, 0x6E, 0x1B, 0x4F,
2466 0x23, 0x71, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65,
2467 0x20, 0x36, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24, 0x2B,
2468 0x4D, 0x1B, 0x4F, 0x22, 0x71, 0x1B, 0x4F, 0x21, 0x4E, 0x1B,
2469 0x4F, 0x21, 0x6A, 0x1B, 0x4F, 0x23, 0x3A, 0x1B, 0x4F, 0x23,
2470 0x6F, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20,
2471 0x37, 0x20, 0x2A, 0x2F,
2472 };
2473 static const unsigned char out2[]={
2474 0x1B, 0x24, 0x29, 0x47, 0x0E, 0x23, 0x21, 0x23, 0x22, 0x23,
2475 0x23, 0x23, 0x24, 0x23, 0x25, 0x23, 0x26, 0x23, 0x27, 0x23,
2476 0x28, 0x23, 0x29, 0x23, 0x2A, 0x23, 0x2B, 0x0F, 0x2F, 0x2A,
2477 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20, 0x31, 0x20, 0x2A, 0x2F,
2478 0x0D, 0x0A, 0x1B, 0x24, 0x2A, 0x48, 0x1B, 0x4E, 0x22, 0x21,
2479 0x1B, 0x4E, 0x22, 0x22, 0x1B, 0x4E, 0x22, 0x23, 0x1B, 0x4E,
2480 0x22, 0x24, 0x1B, 0x4E, 0x22, 0x25, 0x0F, 0x2F, 0x2A, 0x70,
2481 0x6C, 0x61, 0x6E, 0x65, 0x32, 0x2A, 0x2F, 0x20, 0x0D, 0x0A,
2482 0x1B, 0x24, 0x2B, 0x49, 0x1B, 0x4F, 0x22, 0x44, 0x1B, 0x4F,
2483 0x22, 0x45, 0x1B, 0x4F, 0x22, 0x46, 0x1B, 0x4F, 0x22, 0x47,
2484 0x1B, 0x4F, 0x22, 0x48, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61,
2485 0x6E, 0x65, 0x20, 0x33, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B,
2486 0x24, 0x2B, 0x4A, 0x1B, 0x4F, 0x21, 0x44, 0x1B, 0x4F, 0x21,
2487 0x45, 0x1B, 0x4F, 0x22, 0x6A, 0x1B, 0x4F, 0x22, 0x6B, 0x1B,
2488 0x4F, 0x22, 0x6C, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
2489 0x65, 0x20, 0x34, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
2490 0x2B, 0x4B, 0x1B, 0x4F, 0x21, 0x74, 0x1B, 0x4F, 0x22, 0x50,
2491 0x1B, 0x4F, 0x22, 0x51, 0x1B, 0x4F, 0x23, 0x37, 0x1B, 0x4F,
2492 0x22, 0x5C, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
2493 0x65, 0x20, 0x35, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
2494 0x2B, 0x4C, 0x1B, 0x4F, 0x21, 0x23, 0x1B, 0x4F, 0x22, 0x2C,
2495 0x1B, 0x4F, 0x23, 0x4E, 0x1B, 0x4F, 0x21, 0x6E, 0x1B, 0x4F,
2496 0x23, 0x71, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65,
2497 0x20, 0x36, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24, 0x2B,
2498 0x4D, 0x1B, 0x4F, 0x22, 0x71, 0x1B, 0x4F, 0x21, 0x4E, 0x1B,
2499 0x4F, 0x21, 0x6A, 0x1B, 0x4F, 0x23, 0x3A, 0x1B, 0x4F, 0x23,
2500 0x6F, 0x0F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20,
2501 0x37, 0x20, 0x2A, 0x2F,
2502 };
2503 const char *source=(const char *)in;
2504 const char *limit=(const char *)in+sizeof(in);
2505
2506 UErrorCode errorCode=U_ZERO_ERROR;
2507 UConverter *cnv=ucnv_open("LATIN_1", &errorCode);
2508 if(U_FAILURE(errorCode)) {
2509 log_data_err("Unable to open a LATIN_1 converter: %s\n", u_errorName(errorCode));
2510 return;
2511 }
2512 TestNextUChar(cnv, source, limit, results, "LATIN_1");
2513 /* Test the condition when source >= sourceLimit */
2514 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2515 TestConv((uint16_t*)in1,sizeof(in1)/2,"LATIN_1","LATIN-1",(char*)out1,sizeof(out1));
2516 TestConv((uint16_t*)in2,sizeof(in2)/2,"ASCII","ASCII",(char*)out2,sizeof(out2));
2517
2518 ucnv_close(cnv);
2519 }
2520
2521 static void
2522 TestSBCS() {
2523 /* test input */
2524 static const uint8_t in[]={ 0x61, 0xc0, 0x80, 0xe0, 0xf0, 0xf4};
2525 /* expected test results */
2526 static const int32_t results[]={
2527 /* number of bytes read, code point */
2528 1, 0x61,
2529 1, 0xbf,
2530 1, 0xc4,
2531 1, 0x2021,
2532 1, 0xf8ff,
2533 1, 0x00d9
2534 };
2535
2536 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2537 UErrorCode errorCode=U_ZERO_ERROR;
2538 UConverter *cnv=ucnv_open("x-mac-turkish", &errorCode);
2539 if(U_FAILURE(errorCode)) {
2540 log_data_err("Unable to open a SBCS(x-mac-turkish) converter: %s\n", u_errorName(errorCode));
2541 return;
2542 }
2543 TestNextUChar(cnv, source, limit, results, "SBCS(x-mac-turkish)");
2544 /* Test the condition when source >= sourceLimit */
2545 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2546 /*Test for Illegal character */ /*
2547 {
2548 static const uint8_t input1[]={ 0xA1 };
2549 const char* illegalsource=(const char*)input1;
2550 TestNextUCharError(cnv, illegalsource, illegalsource+sizeof(illegalsource), U_INVALID_CHAR_FOUND, "source has a illegal characte");
2551 }
2552 */
2553 ucnv_close(cnv);
2554 }
2555
2556 static void
2557 TestDBCS() {
2558 /* test input */
2559 static const uint8_t in[]={
2560 0x44, 0x6a,
2561 0xc4, 0x9c,
2562 0x7a, 0x74,
2563 0x46, 0xab,
2564 0x42, 0x5b,
2565
2566 };
2567
2568 /* expected test results */
2569 static const int32_t results[]={
2570 /* number of bytes read, code point */
2571 2, 0x00a7,
2572 2, 0xe1d2,
2573 2, 0x6962,
2574 2, 0xf842,
2575 2, 0xffe5,
2576 };
2577
2578 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2579 UErrorCode errorCode=U_ZERO_ERROR;
2580
2581 UConverter *cnv=my_ucnv_open("@ibm9027", &errorCode);
2582 if(U_FAILURE(errorCode)) {
2583 log_data_err("Unable to open a DBCS(@ibm9027) converter: %s\n", u_errorName(errorCode));
2584 return;
2585 }
2586 TestNextUChar(cnv, source, limit, results, "DBCS(@ibm9027)");
2587 /* Test the condition when source >= sourceLimit */
2588 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2589 /*Test for the condition where there is an invalid character*/
2590 {
2591 static const uint8_t source2[]={0x1a, 0x1b};
2592 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character");
2593 }
2594 /*Test for the condition where we have a truncated char*/
2595 {
2596 static const uint8_t source1[]={0xc4};
2597 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
2598 TestNextUCharError(cnv, (const char*)source1, (const char*)source1+sizeof(source1), U_TRUNCATED_CHAR_FOUND, "a character is truncated");
2599 }
2600 ucnv_close(cnv);
2601 }
2602
2603 static void
2604 TestMBCS() {
2605 /* test input */
2606 static const uint8_t in[]={
2607 0x01,
2608 0xa6, 0xa3,
2609 0x00,
2610 0xa6, 0xa1,
2611 0x08,
2612 0xc2, 0x76,
2613 0xc2, 0x78,
2614
2615 };
2616
2617 /* expected test results */
2618 static const int32_t results[]={
2619 /* number of bytes read, code point */
2620 1, 0x0001,
2621 2, 0x250c,
2622 1, 0x0000,
2623 2, 0x2500,
2624 1, 0x0008,
2625 2, 0xd60c,
2626 2, 0xd60e,
2627 };
2628
2629 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2630 UErrorCode errorCode=U_ZERO_ERROR;
2631
2632 UConverter *cnv=ucnv_open("ibm-1363", &errorCode);
2633 if(U_FAILURE(errorCode)) {
2634 log_data_err("Unable to open a MBCS(ibm-1363) converter: %s\n", u_errorName(errorCode));
2635 return;
2636 }
2637 TestNextUChar(cnv, source, limit, results, "MBCS(ibm-1363)");
2638 /* Test the condition when source >= sourceLimit */
2639 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2640 /*Test for the condition where there is an invalid character*/
2641 {
2642 static const uint8_t source2[]={0xa1, 0x80};
2643 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character");
2644 }
2645 /*Test for the condition where we have a truncated char*/
2646 {
2647 static const uint8_t source1[]={0xc4};
2648 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
2649 TestNextUCharError(cnv, (const char*)source1, (const char*)source1+sizeof(source1), U_TRUNCATED_CHAR_FOUND, "a character is truncated");
2650 }
2651 ucnv_close(cnv);
2652
2653 }
2654
2655 #if !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_NO_FILE_IO
2656 static void
2657 TestICCRunout() {
2658 /* { "ibm-1363", :bin{ a2aea2 }, "\u00a1\u001a", :intvector{ 0, 2 }, :int{1}, :int{0}, "\", "?", :bin{""} } */
2659
2660 const char *cnvName = "ibm-1363";
2661 UErrorCode status = U_ZERO_ERROR;
2662 const char sourceData[] = { (char)0xa2, (char)0xae, (char)0xa2 };
2663 /* UChar expectUData[] = { 0x00a1, 0x001a }; */
2664 const char *source = sourceData;
2665 const char *sourceLim = sourceData+sizeof(sourceData);
2666 UChar c1, c2, c3;
2667 UConverter *cnv=ucnv_open(cnvName, &status);
2668 if(U_FAILURE(status)) {
2669 log_data_err("Unable to open %s converter: %s\n", cnvName, u_errorName(status));
2670 return;
2671 }
2672
2673 #if 0
2674 {
2675 UChar targetBuf[256];
2676 UChar *target = targetBuf;
2677 UChar *targetLim = target+256;
2678 ucnv_toUnicode(cnv, &target, targetLim, &source, sourceLim, NULL, TRUE, &status);
2679
2680 log_info("After convert: target@%d, source@%d, status%s\n",
2681 target-targetBuf, source-sourceData, u_errorName(status));
2682
2683 if(U_FAILURE(status)) {
2684 log_err("Failed to convert: %s\n", u_errorName(status));
2685 } else {
2686
2687 }
2688 }
2689 #endif
2690
2691 c1=ucnv_getNextUChar(cnv, &source, sourceLim, &status);
2692 log_verbose("c1: U+%04X, source@%d, status %s\n", c1, source-sourceData, u_errorName(status));
2693
2694 c2=ucnv_getNextUChar(cnv, &source, sourceLim, &status);
2695 log_verbose("c2: U+%04X, source@%d, status %s\n", c2, source-sourceData, u_errorName(status));
2696
2697 c3=ucnv_getNextUChar(cnv, &source, sourceLim, &status);
2698 log_verbose("c3: U+%04X, source@%d, status %s\n", c3, source-sourceData, u_errorName(status));
2699
2700 if(status==U_INDEX_OUTOFBOUNDS_ERROR && c3==0xFFFF) {
2701 log_verbose("OK\n");
2702 } else {
2703 log_err("FAIL: c3 was not FFFF or err was not U_INDEXOUTOFBOUNDS_ERROR\n");
2704 }
2705
2706 ucnv_close(cnv);
2707
2708 }
2709 #endif
2710
2711 #ifdef U_ENABLE_GENERIC_ISO_2022
2712
2713 static void
2714 TestISO_2022() {
2715 /* test input */
2716 static const uint8_t in[]={
2717 0x1b, 0x25, 0x42,
2718 0x31,
2719 0x32,
2720 0x61,
2721 0xc2, 0x80,
2722 0xe0, 0xa0, 0x80,
2723 0xf0, 0x90, 0x80, 0x80
2724 };
2725
2726
2727
2728 /* expected test results */
2729 static const int32_t results[]={
2730 /* number of bytes read, code point */
2731 4, 0x0031, /* 4 bytes including the escape sequence */
2732 1, 0x0032,
2733 1, 0x61,
2734 2, 0x80,
2735 3, 0x800,
2736 4, 0x10000
2737 };
2738
2739 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
2740 UErrorCode errorCode=U_ZERO_ERROR;
2741 UConverter *cnv;
2742
2743 cnv=ucnv_open("ISO_2022", &errorCode);
2744 if(U_FAILURE(errorCode)) {
2745 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
2746 return;
2747 }
2748 TestNextUChar(cnv, source, limit, results, "ISO_2022");
2749
2750 /* Test the condition when source >= sourceLimit */
2751 TestNextUCharError(cnv, source, source-1, U_ILLEGAL_ARGUMENT_ERROR, "sourceLimit < source");
2752 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
2753 /*Test for the condition where we have a truncated char*/
2754 {
2755 static const uint8_t source1[]={0xc4};
2756 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
2757 TestNextUCharError(cnv, (const char*)source1, (const char*)source1+sizeof(source1), U_TRUNCATED_CHAR_FOUND, "a character is truncated");
2758 }
2759 /*Test for the condition where there is an invalid character*/
2760 {
2761 static const uint8_t source2[]={0xa1, 0x01};
2762 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ILLEGAL_CHAR_FOUND, "an invalid character");
2763 }
2764 ucnv_close(cnv);
2765 }
2766
2767 #endif
2768
2769 static void
2770 TestSmallTargetBuffer(const uint16_t* source, const UChar* sourceLimit,UConverter* cnv){
2771 const UChar* uSource;
2772 const UChar* uSourceLimit;
2773 const char* cSource;
2774 const char* cSourceLimit;
2775 UChar *uTargetLimit =NULL;
2776 UChar *uTarget;
2777 char *cTarget;
2778 const char *cTargetLimit;
2779 char *cBuf;
2780 UChar *uBuf; /*,*test;*/
2781 int32_t uBufSize = 120;
2782 int len=0;
2783 int i=2;
2784 UErrorCode errorCode=U_ZERO_ERROR;
2785 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
2786 cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
2787 ucnv_reset(cnv);
2788 for(;--i>0; ){
2789 uSource = (UChar*) source;
2790 uSourceLimit=(const UChar*)sourceLimit;
2791 cTarget = cBuf;
2792 uTarget = uBuf;
2793 cSource = cBuf;
2794 cTargetLimit = cBuf;
2795 uTargetLimit = uBuf;
2796
2797 do{
2798
2799 cTargetLimit = cTargetLimit+ i;
2800 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,NULL,FALSE, &errorCode);
2801 if(errorCode==U_BUFFER_OVERFLOW_ERROR){
2802 errorCode=U_ZERO_ERROR;
2803 continue;
2804 }
2805
2806 if(U_FAILURE(errorCode)){
2807 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
2808 return;
2809 }
2810
2811 }while (uSource<uSourceLimit);
2812
2813 cSourceLimit =cTarget;
2814 do{
2815 uTargetLimit=uTargetLimit+i;
2816 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,NULL,FALSE,&errorCode);
2817 if(errorCode==U_BUFFER_OVERFLOW_ERROR){
2818 errorCode=U_ZERO_ERROR;
2819 continue;
2820 }
2821 if(U_FAILURE(errorCode)){
2822 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
2823 return;
2824 }
2825 }while(cSource<cSourceLimit);
2826
2827 uSource = source;
2828 /*test =uBuf;*/
2829 for(len=0;len<(int)(source - sourceLimit);len++){
2830 if(uBuf[len]!=uSource[len]){
2831 log_err("Expected : \\u%04X \t Got: \\u%04X\n",uSource[len],(int)uBuf[len]) ;
2832 }
2833 }
2834 }
2835 free(uBuf);
2836 free(cBuf);
2837 }
2838 /* Test for Jitterbug 778 */
2839 static void TestToAndFromUChars(const uint16_t* source, const UChar* sourceLimit,UConverter* cnv){
2840 const UChar* uSource;
2841 const UChar* uSourceLimit;
2842 const char* cSource;
2843 UChar *uTargetLimit =NULL;
2844 UChar *uTarget;
2845 char *cTarget;
2846 const char *cTargetLimit;
2847 char *cBuf;
2848 UChar *uBuf,*test;
2849 int32_t uBufSize = 120;
2850 int numCharsInTarget=0;
2851 UErrorCode errorCode=U_ZERO_ERROR;
2852 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
2853 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
2854 uSource = source;
2855 uSourceLimit=sourceLimit;
2856 cTarget = cBuf;
2857 cTargetLimit = cBuf +uBufSize*5;
2858 uTarget = uBuf;
2859 uTargetLimit = uBuf+ uBufSize*5;
2860 ucnv_reset(cnv);
2861 numCharsInTarget=ucnv_fromUChars(cnv, cTarget, (int32_t)(cTargetLimit-cTarget), uSource, (int32_t)(uSourceLimit-uSource), &errorCode);
2862 if(U_FAILURE(errorCode)){
2863 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
2864 return;
2865 }
2866 cSource = cBuf;
2867 test =uBuf;
2868 ucnv_toUChars(cnv,uTarget,(int32_t)(uTargetLimit-uTarget),cSource,numCharsInTarget,&errorCode);
2869 if(U_FAILURE(errorCode)){
2870 log_err("ucnv_toUChars conversion failed, reason %s\n", u_errorName(errorCode));
2871 return;
2872 }
2873 uSource = source;
2874 while(uSource<uSourceLimit){
2875 if(*test!=*uSource){
2876
2877 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
2878 }
2879 uSource++;
2880 test++;
2881 }
2882 free(uBuf);
2883 free(cBuf);
2884 }
2885
2886 static void TestSmallSourceBuffer(const uint16_t* source, const UChar* sourceLimit,UConverter* cnv){
2887 const UChar* uSource;
2888 const UChar* uSourceLimit;
2889 const char* cSource;
2890 const char* cSourceLimit;
2891 UChar *uTargetLimit =NULL;
2892 UChar *uTarget;
2893 char *cTarget;
2894 const char *cTargetLimit;
2895 char *cBuf;
2896 UChar *uBuf; /*,*test;*/
2897 int32_t uBufSize = 120;
2898 int len=0;
2899 int i=2;
2900 const UChar *temp = sourceLimit;
2901 UErrorCode errorCode=U_ZERO_ERROR;
2902 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
2903 cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
2904
2905 ucnv_reset(cnv);
2906 for(;--i>0;){
2907 uSource = (UChar*) source;
2908 cTarget = cBuf;
2909 uTarget = uBuf;
2910 cSource = cBuf;
2911 cTargetLimit = cBuf;
2912 uTargetLimit = uBuf+uBufSize*5;
2913 cTargetLimit = cTargetLimit+uBufSize*10;
2914 uSourceLimit=uSource;
2915 do{
2916
2917 if (uSourceLimit < sourceLimit) {
2918 uSourceLimit = uSourceLimit+1;
2919 }
2920 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,NULL,FALSE, &errorCode);
2921 if(errorCode==U_BUFFER_OVERFLOW_ERROR){
2922 errorCode=U_ZERO_ERROR;
2923 continue;
2924 }
2925
2926 if(U_FAILURE(errorCode)){
2927 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
2928 return;
2929 }
2930
2931 }while (uSource<temp);
2932
2933 cSourceLimit =cBuf;
2934 do{
2935 if (cSourceLimit < cBuf + (cTarget - cBuf)) {
2936 cSourceLimit = cSourceLimit+1;
2937 }
2938 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,NULL,FALSE,&errorCode);
2939 if(errorCode==U_BUFFER_OVERFLOW_ERROR){
2940 errorCode=U_ZERO_ERROR;
2941 continue;
2942 }
2943 if(U_FAILURE(errorCode)){
2944 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
2945 return;
2946 }
2947 }while(cSource<cTarget);
2948
2949 uSource = source;
2950 /*test =uBuf;*/
2951 for(;len<(int)(source - sourceLimit);len++){
2952 if(uBuf[len]!=uSource[len]){
2953 log_err("Expected : \\u%04X \t Got: \\u%04X\n",uSource[len],(int)uBuf[len]) ;
2954 }
2955 }
2956 }
2957 free(uBuf);
2958 free(cBuf);
2959 }
2960 static void
2961 TestGetNextUChar2022(UConverter* cnv, const char* source, const char* limit,
2962 const uint16_t results[], const char* message){
2963 /* const char* s0; */
2964 const char* s=(char*)source;
2965 const uint16_t *r=results;
2966 UErrorCode errorCode=U_ZERO_ERROR;
2967 uint32_t c,exC;
2968 ucnv_reset(cnv);
2969 while(s<limit) {
2970 /* s0=s; */
2971 c=ucnv_getNextUChar(cnv, &s, limit, &errorCode);
2972 if(errorCode==U_INDEX_OUTOFBOUNDS_ERROR) {
2973 break; /* no more significant input */
2974 } else if(U_FAILURE(errorCode)) {
2975 log_err("%s ucnv_getNextUChar() failed: %s\n", message, u_errorName(errorCode));
2976 break;
2977 } else {
2978 if(U16_IS_LEAD(*r)){
2979 int i =0, len = 2;
2980 U16_NEXT(r, i, len, exC);
2981 r++;
2982 }else{
2983 exC = *r;
2984 }
2985 if(c!=(uint32_t)(exC))
2986 log_err("%s ucnv_getNextUChar() Expected: \\u%04X Got: \\u%04X \n",message,(uint32_t) (*r),c);
2987 }
2988 r++;
2989 }
2990 }
2991
2992 static int TestJitterbug930(const char* enc){
2993 UErrorCode err = U_ZERO_ERROR;
2994 UConverter*converter;
2995 char out[80];
2996 char*target = out;
2997 UChar in[4];
2998 const UChar*source = in;
2999 int32_t off[80];
3000 int32_t* offsets = off;
3001 int numOffWritten=0;
3002 UBool flush = 0;
3003 converter = my_ucnv_open(enc, &err);
3004
3005 in[0] = 0x41; /* 0x4E00;*/
3006 in[1] = 0x4E01;
3007 in[2] = 0x4E02;
3008 in[3] = 0x4E03;
3009
3010 memset(off, '*', sizeof(off));
3011
3012 ucnv_fromUnicode (converter,
3013 &target,
3014 target+2,
3015 &source,
3016 source+3,
3017 offsets,
3018 flush,
3019 &err);
3020
3021 /* writes three bytes into the output buffer: 41 1B 24
3022 * but offsets contains 0 1 1
3023 */
3024 while(*offsets< off[10]){
3025 numOffWritten++;
3026 offsets++;
3027 }
3028 log_verbose("Testing Jitterbug 930 for encoding %s",enc);
3029 if(numOffWritten!= (int)(target-out)){
3030 log_err("Jitterbug 930 test for enc: %s failed. Expected: %i Got: %i",enc, (int)(target-out),numOffWritten);
3031 }
3032
3033 err = U_ZERO_ERROR;
3034
3035 memset(off,'*' , sizeof(off));
3036
3037 flush = 1;
3038 offsets=off;
3039 ucnv_fromUnicode (converter,
3040 &target,
3041 target+4,
3042 &source,
3043 source,
3044 offsets,
3045 flush,
3046 &err);
3047 numOffWritten=0;
3048 while(*offsets< off[10]){
3049 numOffWritten++;
3050 if(*offsets!= -1){
3051 log_err("Jitterbug 930 test for enc: %s failed. Expected: %i Got: %i",enc,-1,*offsets) ;
3052 }
3053 offsets++;
3054 }
3055
3056 /* writes 42 43 7A into output buffer,
3057 * offsets contains -1 -1 -1
3058 */
3059 ucnv_close(converter);
3060 return 0;
3061 }
3062
3063 static void
3064 TestHZ() {
3065 /* test input */
3066 static const uint16_t in[]={
3067 0x3000, 0x3001, 0x3002, 0x00B7, 0x02C9, 0x02C7, 0x00A8, 0x3003, 0x3005, 0x2014,
3068 0xFF5E, 0x2016, 0x2026, 0x007E, 0x997C, 0x70B3, 0x75C5, 0x5E76, 0x73BB, 0x83E0,
3069 0x64AD, 0x62E8, 0x94B5, 0x000A, 0x6CE2, 0x535A, 0x52C3, 0x640F, 0x94C2, 0x7B94,
3070 0x4F2F, 0x5E1B, 0x8236, 0x000A, 0x8116, 0x818A, 0x6E24, 0x6CCA, 0x9A73, 0x6355,
3071 0x535C, 0x54FA, 0x8865, 0x000A, 0x57E0, 0x4E0D, 0x5E03, 0x6B65, 0x7C3F, 0x90E8,
3072 0x6016, 0x248F, 0x2490, 0x000A, 0x2491, 0x2492, 0x2493, 0x2494, 0x2495, 0x2496,
3073 0x2497, 0x2498, 0x2499, 0x000A, 0x249A, 0x249B, 0x2474, 0x2475, 0x2476, 0x2477,
3074 0x2478, 0x2479, 0x247A, 0x000A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480,
3075 0x2481, 0x2482, 0x2483, 0x000A, 0x0041, 0x0043, 0x0044, 0x0045, 0x0046, 0x007E,
3076 0x0048, 0x0049, 0x004A, 0x000A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
3077 0x0051, 0x0052, 0x0053, 0x000A, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
3078 0x005A, 0x005B, 0x005C, 0x000A
3079 };
3080 const UChar* uSource;
3081 const UChar* uSourceLimit;
3082 const char* cSource;
3083 const char* cSourceLimit;
3084 UChar *uTargetLimit =NULL;
3085 UChar *uTarget;
3086 char *cTarget;
3087 const char *cTargetLimit;
3088 char *cBuf;
3089 UChar *uBuf,*test;
3090 int32_t uBufSize = 120;
3091 UErrorCode errorCode=U_ZERO_ERROR;
3092 UConverter *cnv;
3093 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
3094 int32_t* myOff= offsets;
3095 cnv=ucnv_open("HZ", &errorCode);
3096 if(U_FAILURE(errorCode)) {
3097 log_data_err("Unable to open HZ converter: %s\n", u_errorName(errorCode));
3098 return;
3099 }
3100
3101 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
3102 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
3103 uSource = (const UChar*)in;
3104 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
3105 cTarget = cBuf;
3106 cTargetLimit = cBuf +uBufSize*5;
3107 uTarget = uBuf;
3108 uTargetLimit = uBuf+ uBufSize*5;
3109 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
3110 if(U_FAILURE(errorCode)){
3111 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
3112 return;
3113 }
3114 cSource = cBuf;
3115 cSourceLimit =cTarget;
3116 test =uBuf;
3117 myOff=offsets;
3118 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
3119 if(U_FAILURE(errorCode)){
3120 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
3121 return;
3122 }
3123 uSource = (const UChar*)in;
3124 while(uSource<uSourceLimit){
3125 if(*test!=*uSource){
3126
3127 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
3128 }
3129 uSource++;
3130 test++;
3131 }
3132 TestGetNextUChar2022(cnv, cBuf, cTarget, in, "HZ encoding");
3133 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3134 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3135 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3136 TestJitterbug930("csISO2022JP");
3137 ucnv_close(cnv);
3138 free(offsets);
3139 free(uBuf);
3140 free(cBuf);
3141 }
3142
3143 static void
3144 TestISCII(){
3145 /* test input */
3146 static const uint16_t in[]={
3147 /* test full range of Devanagari */
3148 0x0901,0x0902,0x0903,0x0905,0x0906,0x0907,0x0908,0x0909,0x090A,
3149 0x090B,0x090E,0x090F,0x0910,0x090D,0x0912,0x0913,0x0914,0x0911,
3150 0x0915,0x0916,0x0917,0x0918,0x0919,0x091A,0x091B,0x091C,0x091D,
3151 0x091E,0x091F,0x0920,0x0921,0x0922,0x0923,0x0924,0x0925,0x0926,
3152 0x0927,0x0928,0x0929,0x092A,0x092B,0x092C,0x092D,0x092E,0x092F,
3153 0x095F,0x0930,0x0931,0x0932,0x0933,0x0934,0x0935,0x0936,0x0937,
3154 0x0938,0x0939,0x200D,0x093E,0x093F,0x0940,0x0941,0x0942,0x0943,
3155 0x0946,0x0947,0x0948,0x0945,0x094A,0x094B,0x094C,0x0949,0x094D,
3156 0x093d,0x0966,0x0967,0x0968,0x0969,0x096A,0x096B,0x096C,
3157 0x096D,0x096E,0x096F,
3158 /* test Soft halant*/
3159 0x0915,0x094d, 0x200D,
3160 /* test explicit halant */
3161 0x0915,0x094d, 0x200c,
3162 /* test double danda */
3163 0x965,
3164 /* test ASCII */
3165 0x1B, 0x24, 0x29, 0x47, 0x0E, 0x23, 0x21, 0x23, 0x22, 0x23,
3166 0x23, 0x23, 0x24, 0x23, 0x25, 0x23, 0x26, 0x23, 0x27, 0x23,
3167 0x28, 0x23, 0x29, 0x23, 0x2A, 0x23, 0x2B, 0x0F, 0x2F, 0x2A,
3168 /* tests from Lotus */
3169 0x0061,0x0915,0x000D,0x000A,0x0996,0x0043,
3170 0x0930,0x094D,0x200D,
3171 0x0901,0x000D,0x000A,0x0905,0x0985,0x0043,
3172 0x0915,0x0921,0x002B,0x095F,
3173 /* tamil range */
3174 0x0B86, 0xB87, 0xB88,
3175 /* telugu range */
3176 0x0C05, 0x0C02, 0x0C03,0x0c31,
3177 /* kannada range */
3178 0x0C85, 0xC82, 0x0C83,
3179 /* test Abbr sign and Anudatta */
3180 0x0970, 0x952,
3181 /* 0x0958,
3182 0x0959,
3183 0x095A,
3184 0x095B,
3185 0x095C,
3186 0x095D,
3187 0x095E,
3188 0x095F,*/
3189 0x0960 /* Vocallic RRI 0xAB, 0xE9*/,
3190 0x0944 /* Vowel Sign Vocallic RRI 0xDF, 0xE9 */,
3191 0x090C ,
3192 0x0962,
3193 0x0961 /* Vocallic LL 0xa6, 0xE9 */,
3194 0x0963 /* Vowel Sign Vocallic LL 0xdb, 0xE9, */,
3195 0x0950 /* OM Symbol 0xa1, 0xE9,*/,
3196 0x093D /* Avagraha 0xEA, 0xE9*/,
3197 0x0958,
3198 0x0959,
3199 0x095A,
3200 0x095B,
3201 0x095C,
3202 0x095D,
3203 0x095E,
3204 0x0020, 0x094D, 0x0930, 0x0000, 0x00A0
3205 };
3206 static const unsigned char byteArr[]={
3207
3208 0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,
3209 0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,
3210 0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,
3211 0xbc,0xbd,0xbe,0xbf,0xc0,0xc1,0xc2,0xc3,0xc4,
3212 0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,
3213 0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,
3214 0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf,
3215 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,
3216 0xea,0xe9,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,
3217 0xf8,0xf9,0xfa,
3218 /* test soft halant */
3219 0xb3, 0xE8, 0xE9,
3220 /* test explicit halant */
3221 0xb3, 0xE8, 0xE8,
3222 /* test double danda */
3223 0xea, 0xea,
3224 /* test ASCII */
3225 0x1B, 0x24, 0x29, 0x47, 0x0E, 0x23, 0x21, 0x23, 0x22, 0x23,
3226 0x23, 0x23, 0x24, 0x23, 0x25, 0x23, 0x26, 0x23, 0x27, 0x23,
3227 0x28, 0x23, 0x29, 0x23, 0x2A, 0x23, 0x2B, 0x0F, 0x2F, 0x2A,
3228 /* test ATR code */
3229
3230 /* tests from Lotus */
3231 0x61,0xEF,0x42,0xEF,0x30,0xB3,0x0D,0x0A,0xEF,0x43,0xB4,0x43,
3232 0xEF,0x42,0xCF,0xE8,0xD9,
3233 0xEF,0x42,0xA1,0x0D,0x0A,0xEF,0x42,0xA4,0xEF,0x43,0xA4,0x43,
3234 0xEF,0x42,0xB3,0xBF,0x2B,0xEF,0x42,0xCE,
3235 /* tamil range */
3236 0xEF, 0x44, 0xa5, 0xa6, 0xa7,
3237 /* telugu range */
3238 0xEF, 0x45,0xa4, 0xa2, 0xa3,0xd0,
3239 /* kannada range */
3240 0xEF, 0x48,0xa4, 0xa2, 0xa3,
3241 /* anudatta and abbreviation sign */
3242 0xEF, 0x42, 0xF0, 0xBF, 0xF0, 0xB8,
3243
3244
3245 0xAA, 0xE9,/* RI + NUKTA 0x0960*/
3246
3247 0xDF, 0xE9,/* Vowel sign RI + NUKTA 0x0944*/
3248
3249 0xa6, 0xE9,/* Vowel I + NUKTA 0x090C*/
3250
3251 0xdb, 0xE9,/* Vowel sign I + Nukta 0x0962*/
3252
3253 0xa7, 0xE9,/* Vowel II + NUKTA 0x0961*/
3254
3255 0xdc, 0xE9,/* Vowel sign II + Nukta 0x0963*/
3256
3257 0xa1, 0xE9,/* chandrabindu + Nukta 0x0950*/
3258
3259 0xEA, 0xE9, /* Danda + Nukta 0x093D*/
3260
3261 0xB3, 0xE9, /* Ka + NUKTA */
3262
3263 0xB4, 0xE9, /* Kha + NUKTA */
3264
3265 0xB5, 0xE9, /* Ga + NUKTA */
3266
3267 0xBA, 0xE9,
3268
3269 0xBF, 0xE9,
3270
3271 0xC0, 0xE9,
3272
3273 0xC9, 0xE9,
3274 /* INV halant RA */
3275 0xD9, 0xE8, 0xCF,
3276 0x00, 0x00A0,
3277 /* just consume unhandled codepoints */
3278 0xEF, 0x30,
3279
3280 };
3281 testConvertToU(byteArr,(sizeof(byteArr)),in,UPRV_LENGTHOF(in),"x-iscii-de",NULL,TRUE);
3282 TestConv(in,(sizeof(in)/2),"ISCII,version=0","hindi", (char *)byteArr,sizeof(byteArr));
3283
3284 }
3285
3286 static void
3287 TestISO_2022_JP() {
3288 /* test input */
3289 static const uint16_t in[]={
3290 0x0041,/*0x00E9,*/0x3000, 0x3001, 0x3002, 0x0020, 0x000D, 0x000A,
3291 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
3292 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
3293 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F, 0x005C, 0x000D, 0x000A,
3294 0x3013, 0x2018, 0x2026, 0x2025, 0x2018, 0x2019, 0x201C, 0x000D, 0x000A,
3295 0x201D, 0x3014, 0x000D, 0x000A,
3296 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3297 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3298 };
3299 const UChar* uSource;
3300 const UChar* uSourceLimit;
3301 const char* cSource;
3302 const char* cSourceLimit;
3303 UChar *uTargetLimit =NULL;
3304 UChar *uTarget;
3305 char *cTarget;
3306 const char *cTargetLimit;
3307 char *cBuf;
3308 UChar *uBuf,*test;
3309 int32_t uBufSize = 120;
3310 UErrorCode errorCode=U_ZERO_ERROR;
3311 UConverter *cnv;
3312 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
3313 int32_t* myOff= offsets;
3314 cnv=ucnv_open("ISO_2022_JP_1", &errorCode);
3315 if(U_FAILURE(errorCode)) {
3316 log_data_err("Unable to open an ISO_2022_JP_1 converter: %s\n", u_errorName(errorCode));
3317 return;
3318 }
3319
3320 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
3321 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
3322 uSource = (const UChar*)in;
3323 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
3324 cTarget = cBuf;
3325 cTargetLimit = cBuf +uBufSize*5;
3326 uTarget = uBuf;
3327 uTargetLimit = uBuf+ uBufSize*5;
3328 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
3329 if(U_FAILURE(errorCode)){
3330 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
3331 return;
3332 }
3333 cSource = cBuf;
3334 cSourceLimit =cTarget;
3335 test =uBuf;
3336 myOff=offsets;
3337 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
3338 if(U_FAILURE(errorCode)){
3339 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
3340 return;
3341 }
3342
3343 uSource = (const UChar*)in;
3344 while(uSource<uSourceLimit){
3345 if(*test!=*uSource){
3346
3347 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
3348 }
3349 uSource++;
3350 test++;
3351 }
3352
3353 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3354 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3355 TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-JP encoding");
3356 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3357 TestJitterbug930("csISO2022JP");
3358 ucnv_close(cnv);
3359 free(uBuf);
3360 free(cBuf);
3361 free(offsets);
3362 }
3363
3364 static void TestConv(const uint16_t in[],int len, const char* conv, const char* lang, char byteArr[],int byteArrLen){
3365 const UChar* uSource;
3366 const UChar* uSourceLimit;
3367 const char* cSource;
3368 const char* cSourceLimit;
3369 UChar *uTargetLimit =NULL;
3370 UChar *uTarget;
3371 char *cTarget;
3372 const char *cTargetLimit;
3373 char *cBuf;
3374 UChar *uBuf,*test;
3375 int32_t uBufSize = 120*10;
3376 UErrorCode errorCode=U_ZERO_ERROR;
3377 UConverter *cnv;
3378 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) );
3379 int32_t* myOff= offsets;
3380 cnv=my_ucnv_open(conv, &errorCode);
3381 if(U_FAILURE(errorCode)) {
3382 log_data_err("Unable to open a %s converter: %s\n", conv, u_errorName(errorCode));
3383 return;
3384 }
3385
3386 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar));
3387 cBuf =(char*)malloc(uBufSize * sizeof(char));
3388 uSource = (const UChar*)in;
3389 uSourceLimit=uSource+len;
3390 cTarget = cBuf;
3391 cTargetLimit = cBuf +uBufSize;
3392 uTarget = uBuf;
3393 uTargetLimit = uBuf+ uBufSize;
3394 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
3395 if(U_FAILURE(errorCode)){
3396 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
3397 return;
3398 }
3399 /*log_verbose("length of compressed string for language %s using %s:%i \n",conv,lang,(cTarget-cBuf));*/
3400 cSource = cBuf;
3401 cSourceLimit =cTarget;
3402 test =uBuf;
3403 myOff=offsets;
3404 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
3405 if(U_FAILURE(errorCode)){
3406 log_err("ucnv_toUnicode conversion failed, reason: %s\n", u_errorName(errorCode));
3407 return;
3408 }
3409
3410 uSource = (const UChar*)in;
3411 while(uSource<uSourceLimit){
3412 if(*test!=*uSource){
3413 log_err("for codepage %s : Expected : \\u%04X \t Got: \\u%04X\n",conv,*uSource,(int)*test) ;
3414 }
3415 uSource++;
3416 test++;
3417 }
3418 TestSmallTargetBuffer(in,(const UChar*)&in[len],cnv);
3419 TestSmallSourceBuffer(in,(const UChar*)&in[len],cnv);
3420 TestGetNextUChar2022(cnv, cBuf, cTarget, in, conv);
3421 if(byteArr && byteArrLen!=0){
3422 TestGetNextUChar2022(cnv, byteArr, (byteArr+byteArrLen), in, lang);
3423 TestToAndFromUChars(in,(const UChar*)&in[len],cnv);
3424 {
3425 cSource = byteArr;
3426 cSourceLimit = cSource+byteArrLen;
3427 test=uBuf;
3428 myOff = offsets;
3429 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
3430 if(U_FAILURE(errorCode)){
3431 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
3432 return;
3433 }
3434
3435 uSource = (const UChar*)in;
3436 while(uSource<uSourceLimit){
3437 if(*test!=*uSource){
3438 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
3439 }
3440 uSource++;
3441 test++;
3442 }
3443 }
3444 }
3445
3446 ucnv_close(cnv);
3447 free(uBuf);
3448 free(cBuf);
3449 free(offsets);
3450 }
3451 static UChar U_CALLCONV
3452 _charAt(int32_t offset, void *context) {
3453 return ((char*)context)[offset];
3454 }
3455
3456 static int32_t
3457 unescape(UChar* dst, int32_t dstLen,const char* src,int32_t srcLen,UErrorCode *status){
3458 int32_t srcIndex=0;
3459 int32_t dstIndex=0;
3460 if(U_FAILURE(*status)){
3461 return 0;
3462 }
3463 if((dst==NULL && dstLen>0) || (src==NULL ) || dstLen < -1 || srcLen <-1 ){
3464 *status = U_ILLEGAL_ARGUMENT_ERROR;
3465 return 0;
3466 }
3467 if(srcLen==-1){
3468 srcLen = (int32_t)uprv_strlen(src);
3469 }
3470
3471 for (; srcIndex<srcLen; ) {
3472 UChar32 c = src[srcIndex++];
3473 if (c == 0x005C /*'\\'*/) {
3474 c = u_unescapeAt(_charAt,&srcIndex,srcLen,(void*)src); /* advances i*/
3475 if (c == (UChar32)0xFFFFFFFF) {
3476 *status=U_INVALID_CHAR_FOUND; /* return empty string */
3477 break; /* invalid escape sequence */
3478 }
3479 }
3480 if(dstIndex < dstLen){
3481 if(c>0xFFFF){
3482 dst[dstIndex++] = U16_LEAD(c);
3483 if(dstIndex<dstLen){
3484 dst[dstIndex]=U16_TRAIL(c);
3485 }else{
3486 *status=U_BUFFER_OVERFLOW_ERROR;
3487 }
3488 }else{
3489 dst[dstIndex]=(UChar)c;
3490 }
3491
3492 }else{
3493 *status = U_BUFFER_OVERFLOW_ERROR;
3494 }
3495 dstIndex++; /* for preflighting */
3496 }
3497 return dstIndex;
3498 }
3499
3500 static void
3501 TestFullRoundtrip(const char* cp){
3502 UChar usource[10] ={0};
3503 UChar nsrc[10] = {0};
3504 uint32_t i=1;
3505 int len=0, ulen;
3506 nsrc[0]=0x0061;
3507 /* Test codepoint 0 */
3508 TestConv(usource,1,cp,"",NULL,0);
3509 TestConv(usource,2,cp,"",NULL,0);
3510 nsrc[2]=0x5555;
3511 TestConv(nsrc,3,cp,"",NULL,0);
3512
3513 for(;i<=0x10FFFF;i++){
3514 if(i==0xD800){
3515 i=0xDFFF;
3516 continue;
3517 }
3518 if(i<=0xFFFF){
3519 usource[0] =(UChar) i;
3520 len=1;
3521 }else{
3522 usource[0]=U16_LEAD(i);
3523 usource[1]=U16_TRAIL(i);
3524 len=2;
3525 }
3526 ulen=len;
3527 if(i==0x80) {
3528 usource[2]=0;
3529 }
3530 /* Test only single code points */
3531 TestConv(usource,ulen,cp,"",NULL,0);
3532 /* Test codepoint repeated twice */
3533 usource[ulen]=usource[0];
3534 usource[ulen+1]=usource[1];
3535 ulen+=len;
3536 TestConv(usource,ulen,cp,"",NULL,0);
3537 /* Test codepoint repeated 3 times */
3538 usource[ulen]=usource[0];
3539 usource[ulen+1]=usource[1];
3540 ulen+=len;
3541 TestConv(usource,ulen,cp,"",NULL,0);
3542 /* Test codepoint in between 2 codepoints */
3543 nsrc[1]=usource[0];
3544 nsrc[2]=usource[1];
3545 nsrc[len+1]=0x5555;
3546 TestConv(nsrc,len+2,cp,"",NULL,0);
3547 uprv_memset(usource,0,sizeof(UChar)*10);
3548 }
3549 }
3550
3551 static void
3552 TestRoundTrippingAllUTF(void){
3553 if(!getTestOption(QUICK_OPTION)){
3554 log_verbose("Running exhaustive round trip test for BOCU-1\n");
3555 TestFullRoundtrip("BOCU-1");
3556 log_verbose("Running exhaustive round trip test for SCSU\n");
3557 TestFullRoundtrip("SCSU");
3558 log_verbose("Running exhaustive round trip test for UTF-8\n");
3559 TestFullRoundtrip("UTF-8");
3560 log_verbose("Running exhaustive round trip test for CESU-8\n");
3561 TestFullRoundtrip("CESU-8");
3562 log_verbose("Running exhaustive round trip test for UTF-16BE\n");
3563 TestFullRoundtrip("UTF-16BE");
3564 log_verbose("Running exhaustive round trip test for UTF-16LE\n");
3565 TestFullRoundtrip("UTF-16LE");
3566 log_verbose("Running exhaustive round trip test for UTF-16\n");
3567 TestFullRoundtrip("UTF-16");
3568 log_verbose("Running exhaustive round trip test for UTF-32BE\n");
3569 TestFullRoundtrip("UTF-32BE");
3570 log_verbose("Running exhaustive round trip test for UTF-32LE\n");
3571 TestFullRoundtrip("UTF-32LE");
3572 log_verbose("Running exhaustive round trip test for UTF-32\n");
3573 TestFullRoundtrip("UTF-32");
3574 log_verbose("Running exhaustive round trip test for UTF-7\n");
3575 TestFullRoundtrip("UTF-7");
3576 log_verbose("Running exhaustive round trip test for UTF-7\n");
3577 TestFullRoundtrip("UTF-7,version=1");
3578 log_verbose("Running exhaustive round trip test for IMAP-mailbox-name\n");
3579 TestFullRoundtrip("IMAP-mailbox-name");
3580 /*
3581 *
3582 * With the update to GB18030 2005 (Ticket #8274), this test will fail because the 2005 version of
3583 * GB18030 contains mappings to actual Unicode codepoints (which were previously mapped to PUA).
3584 * The old mappings remain as fallbacks.
3585 * This test may be reintroduced at a later time.
3586 *
3587 * 110118 - mow
3588 */
3589 /*
3590 log_verbose("Running exhaustive round trip test for GB18030\n");
3591 TestFullRoundtrip("GB18030");
3592 */
3593 }
3594 }
3595
3596 static void
3597 TestSCSU() {
3598
3599 static const uint16_t germanUTF16[]={
3600 0x00d6, 0x006c, 0x0020, 0x0066, 0x006c, 0x0069, 0x0065, 0x00df, 0x0074
3601 };
3602
3603 static const uint8_t germanSCSU[]={
3604 0xd6, 0x6c, 0x20, 0x66, 0x6c, 0x69, 0x65, 0xdf, 0x74
3605 };
3606
3607 static const uint16_t russianUTF16[]={
3608 0x041c, 0x043e, 0x0441, 0x043a, 0x0432, 0x0430
3609 };
3610
3611 static const uint8_t russianSCSU[]={
3612 0x12, 0x9c, 0xbe, 0xc1, 0xba, 0xb2, 0xb0
3613 };
3614
3615 static const uint16_t japaneseUTF16[]={
3616 0x3000, 0x266a, 0x30ea, 0x30f3, 0x30b4, 0x53ef, 0x611b,
3617 0x3044, 0x3084, 0x53ef, 0x611b, 0x3044, 0x3084, 0x30ea, 0x30f3,
3618 0x30b4, 0x3002, 0x534a, 0x4e16, 0x7d00, 0x3082, 0x524d, 0x306b,
3619 0x6d41, 0x884c, 0x3057, 0x305f, 0x300c, 0x30ea, 0x30f3, 0x30b4,
3620 0x306e, 0x6b4c, 0x300d, 0x304c, 0x3074, 0x3063, 0x305f, 0x308a,
3621 0x3059, 0x308b, 0x304b, 0x3082, 0x3057, 0x308c, 0x306a, 0x3044,
3622 0x3002, 0x7c73, 0x30a2, 0x30c3, 0x30d7, 0x30eb, 0x30b3, 0x30f3,
3623 0x30d4, 0x30e5, 0x30fc, 0x30bf, 0x793e, 0x306e, 0x30d1, 0x30bd,
3624 0x30b3, 0x30f3, 0x300c, 0x30de, 0x30c3, 0x30af, 0xff08, 0x30de,
3625 0x30c3, 0x30ad, 0x30f3, 0x30c8, 0x30c3, 0x30b7, 0x30e5, 0xff09,
3626 0x300d, 0x3092, 0x3001, 0x3053, 0x3088, 0x306a, 0x304f, 0x611b,
3627 0x3059, 0x308b, 0x4eba, 0x305f, 0x3061, 0x306e, 0x3053, 0x3068,
3628 0x3060, 0x3002, 0x300c, 0x30a2, 0x30c3, 0x30d7, 0x30eb, 0x4fe1,
3629 0x8005, 0x300d, 0x306a, 0x3093, 0x3066, 0x8a00, 0x3044, 0x65b9,
3630 0x307e, 0x3067, 0x3042, 0x308b, 0x3002
3631 };
3632
3633 /* SCSUEncoder produces a slightly longer result (179B vs. 178B) because of one different choice:
3634 it uses an SQn once where a longer look-ahead could have shown that SCn is more efficient */
3635 static const uint8_t japaneseSCSU[]={
3636 0x08, 0x00, 0x1b, 0x4c, 0xea, 0x16, 0xca, 0xd3, 0x94, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84,
3637 0xc4, 0x0f, 0x53, 0xef, 0x61, 0x1b, 0xe5, 0x84, 0xc4, 0x16, 0xca, 0xd3, 0x94, 0x08, 0x02, 0x0f,
3638 0x53, 0x4a, 0x4e, 0x16, 0x7d, 0x00, 0x30, 0x82, 0x52, 0x4d, 0x30, 0x6b, 0x6d, 0x41, 0x88, 0x4c,
3639 0xe5, 0x97, 0x9f, 0x08, 0x0c, 0x16, 0xca, 0xd3, 0x94, 0x15, 0xae, 0x0e, 0x6b, 0x4c, 0x08, 0x0d,
3640 0x8c, 0xb4, 0xa3, 0x9f, 0xca, 0x99, 0xcb, 0x8b, 0xc2, 0x97, 0xcc, 0xaa, 0x84, 0x08, 0x02, 0x0e,
3641 0x7c, 0x73, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x93, 0xd3, 0xb4, 0xc5, 0xdc, 0x9f, 0x0e, 0x79, 0x3e,
3642 0x06, 0xae, 0xb1, 0x9d, 0x93, 0xd3, 0x08, 0x0c, 0xbe, 0xa3, 0x8f, 0x08, 0x88, 0xbe, 0xa3, 0x8d,
3643 0xd3, 0xa8, 0xa3, 0x97, 0xc5, 0x17, 0x89, 0x08, 0x0d, 0x15, 0xd2, 0x08, 0x01, 0x93, 0xc8, 0xaa,
3644 0x8f, 0x0e, 0x61, 0x1b, 0x99, 0xcb, 0x0e, 0x4e, 0xba, 0x9f, 0xa1, 0xae, 0x93, 0xa8, 0xa0, 0x08,
3645 0x02, 0x08, 0x0c, 0xe2, 0x16, 0xa3, 0xb7, 0xcb, 0x0f, 0x4f, 0xe1, 0x80, 0x05, 0xec, 0x60, 0x8d,
3646 0xea, 0x06, 0xd3, 0xe6, 0x0f, 0x8a, 0x00, 0x30, 0x44, 0x65, 0xb9, 0xe4, 0xfe, 0xe7, 0xc2, 0x06,
3647 0xcb, 0x82
3648 };
3649
3650 static const uint16_t allFeaturesUTF16[]={
3651 0x0041, 0x00df, 0x0401, 0x015f, 0x00df, 0x01df, 0xf000, 0xdbff,
3652 0xdfff, 0x000d, 0x000a, 0x0041, 0x00df, 0x0401, 0x015f, 0x00df,
3653 0x01df, 0xf000, 0xdbff, 0xdfff
3654 };
3655
3656 /* see comment at japaneseSCSU: the same kind of different choice yields a slightly shorter
3657 * result here (34B vs. 35B)
3658 */
3659 static const uint8_t allFeaturesSCSU[]={
3660 0x41, 0xdf, 0x12, 0x81, 0x03, 0x5f, 0x10, 0xdf, 0x1b, 0x03,
3661 0xdf, 0x1c, 0x88, 0x80, 0x0b, 0xbf, 0xff, 0xff, 0x0d, 0x0a,
3662 0x41, 0x10, 0xdf, 0x12, 0x81, 0x03, 0x5f, 0x10, 0xdf, 0x13,
3663 0xdf, 0x14, 0x80, 0x15, 0xff
3664 };
3665 static const uint16_t monkeyIn[]={
3666 0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
3667 0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
3668 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
3669 0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
3670 0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
3671 0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
3672 0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
3673 0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
3674 0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
3675 0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
3676 0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
3677 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
3678 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
3679 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3680 0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
3681 0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
3682 0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
3683 0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
3684 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A,
3685 /* test non-BMP code points */
3686 0xD869, 0xDE99, 0xD869, 0xDE9C, 0xD869, 0xDE9D, 0xD869, 0xDE9E, 0xD869, 0xDE9F,
3687 0xD869, 0xDEA0, 0xD869, 0xDEA5, 0xD869, 0xDEA6, 0xD869, 0xDEA7, 0xD869, 0xDEA8,
3688 0xD869, 0xDEAB, 0xD869, 0xDEAC, 0xD869, 0xDEAD, 0xD869, 0xDEAE, 0xD869, 0xDEAF,
3689 0xD869, 0xDEB0, 0xD869, 0xDEB1, 0xD869, 0xDEB3, 0xD869, 0xDEB5, 0xD869, 0xDEB6,
3690 0xD869, 0xDEB7, 0xD869, 0xDEB8, 0xD869, 0xDEB9, 0xD869, 0xDEBA, 0xD869, 0xDEBB,
3691 0xD869, 0xDEBC, 0xD869, 0xDEBD, 0xD869, 0xDEBE, 0xD869, 0xDEBF, 0xD869, 0xDEC0,
3692 0xD869, 0xDEC1, 0xD869, 0xDEC2, 0xD869, 0xDEC3, 0xD869, 0xDEC4, 0xD869, 0xDEC8,
3693 0xD869, 0xDECA, 0xD869, 0xDECB, 0xD869, 0xDECD, 0xD869, 0xDECE, 0xD869, 0xDECF,
3694 0xD869, 0xDED0, 0xD869, 0xDED1, 0xD869, 0xDED2, 0xD869, 0xDED3, 0xD869, 0xDED4,
3695 0xD869, 0xDED5, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xDBFF, 0xDFFF,
3696 0xDBFF, 0xDFFF, 0xDBFF, 0xDFFF,
3697
3698
3699 0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
3700 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
3701 0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
3702 0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
3703 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,
3704 };
3705 static const char *fTestCases [] = {
3706 "\\ud800\\udc00", /* smallest surrogate*/
3707 "\\ud8ff\\udcff",
3708 "\\udBff\\udFff", /* largest surrogate pair*/
3709 "\\ud834\\udc00",
3710 "\\U0010FFFF",
3711 "Hello \\u9292 \\u9192 World!",
3712 "Hell\\u0429o \\u9292 \\u9192 W\\u00e4rld!",
3713 "Hell\\u0429o \\u9292 \\u9292W\\u00e4rld!",
3714
3715 "\\u0648\\u06c8", /* catch missing reset*/
3716 "\\u0648\\u06c8",
3717
3718 "\\u4444\\uE001", /* lowest quotable*/
3719 "\\u4444\\uf2FF", /* highest quotable*/
3720 "\\u4444\\uf188\\u4444",
3721 "\\u4444\\uf188\\uf288",
3722 "\\u4444\\uf188abc\\u0429\\uf288",
3723 "\\u9292\\u2222",
3724 "Hell\\u0429\\u04230o \\u9292 \\u9292W\\u00e4\\u0192rld!",
3725 "Hell\\u0429o \\u9292 \\u9292W\\u00e4rld!",
3726 "Hello World!123456",
3727 "Hello W\\u0081\\u011f\\u0082!", /* Latin 1 run*/
3728
3729 "abc\\u0301\\u0302", /* uses SQn for u301 u302*/
3730 "abc\\u4411d", /* uses SQU*/
3731 "abc\\u4411\\u4412d",/* uses SCU*/
3732 "abc\\u0401\\u0402\\u047f\\u00a5\\u0405", /* uses SQn for ua5*/
3733 "\\u9191\\u9191\\u3041\\u9191\\u3041\\u3041\\u3000", /* SJIS like data*/
3734 "\\u9292\\u2222",
3735 "\\u9191\\u9191\\u3041\\u9191\\u3041\\u3041\\u3000",
3736 "\\u9999\\u3051\\u300c\\u9999\\u9999\\u3060\\u9999\\u3065\\u3065\\u3065\\u300c",
3737 "\\u3000\\u266a\\u30ea\\u30f3\\u30b4\\u53ef\\u611b\\u3044\\u3084\\u53ef\\u611b\\u3044\\u3084\\u30ea\\u30f3\\u30b4\\u3002",
3738
3739 "", /* empty input*/
3740 "\\u0000", /* smallest BMP character*/
3741 "\\uFFFF", /* largest BMP character*/
3742
3743 /* regression tests*/
3744 "\\u6441\\ub413\\ua733\\uf8fe\\ueedb\\u587f\\u195f\\u4899\\uf23d\\u49fd\\u0aac\\u5792\\ufc22\\ufc3c\\ufc46\\u00aa",
3745 "\\u00df\\u01df\\uf000\\udbff\\udfff\\u000d\n\\u0041\\u00df\\u0401\\u015f\\u00df\\u01df\\uf000\\udbff\\udfff",
3746 "\\u30f9\\u8321\\u05e5\\u181c\\ud72b\\u2019\\u99c9\\u2f2f\\uc10c\\u82e1\\u2c4d\\u1ebc\\u6013\\u66dc\\ubbde\\u94a5\\u4726\\u74af\\u3083\\u55b9\\u000c",
3747 "\\u0041\\u00df\\u0401\\u015f",
3748 "\\u9066\\u2123abc",
3749 "\\ud266\\u43d7\\u\\ue386\\uc9c0\\u4a6b\\u9222\\u901f\\u7410\\ua63f\\u539b\\u9596\\u482e\\u9d47\\ucfe4\\u7b71\\uc280\\uf26a\\u982f\\u862a\\u4edd\\uf513\\ufda6\\u869d\\u2ee0\\ua216\\u3ff6\\u3c70\\u89c0\\u9576\\ud5ec\\ubfda\\u6cca\\u5bb3\\ubcea\\u554c\\u914e\\ufa4a\\uede3\\u2990\\ud2f5\\u2729\\u5141\\u0f26\\uccd8\\u5413\\ud196\\ubbe2\\u51b9\\u9b48\\u0dc8\\u2195\\u21a2\\u21e9\\u00e4\\u9d92\\u0bc0\\u06c5",
3750 "\\uf95b\\u2458\\u2468\\u0e20\\uf51b\\ue36e\\ubfc1\\u0080\\u02dd\\uf1b5\\u0cf3\\u6059\\u7489",
3751 };
3752 int i=0;
3753 for(;i<UPRV_LENGTHOF(fTestCases);i++){
3754 const char* cSrc = fTestCases[i];
3755 UErrorCode status = U_ZERO_ERROR;
3756 int32_t cSrcLen,srcLen;
3757 UChar* src;
3758 /* UConverter* cnv = ucnv_open("SCSU",&status); */
3759 cSrcLen = srcLen = (int32_t)uprv_strlen(fTestCases[i]);
3760 src = (UChar*) malloc((sizeof(UChar) * srcLen) + sizeof(UChar));
3761 srcLen=unescape(src,srcLen,cSrc,cSrcLen,&status);
3762 log_verbose("Testing roundtrip for src: %s at index :%d\n",cSrc,i);
3763 TestConv(src,srcLen,"SCSU","Coverage",NULL,0);
3764 free(src);
3765 }
3766 TestConv(allFeaturesUTF16,(sizeof(allFeaturesUTF16)/2),"SCSU","all features", (char *)allFeaturesSCSU,sizeof(allFeaturesSCSU));
3767 TestConv(allFeaturesUTF16,(sizeof(allFeaturesUTF16)/2),"SCSU","all features",(char *)allFeaturesSCSU,sizeof(allFeaturesSCSU));
3768 TestConv(japaneseUTF16,(sizeof(japaneseUTF16)/2),"SCSU","japaneese",(char *)japaneseSCSU,sizeof(japaneseSCSU));
3769 TestConv(japaneseUTF16,(sizeof(japaneseUTF16)/2),"SCSU,locale=ja","japaneese",(char *)japaneseSCSU,sizeof(japaneseSCSU));
3770 TestConv(germanUTF16,(sizeof(germanUTF16)/2),"SCSU","german",(char *)germanSCSU,sizeof(germanSCSU));
3771 TestConv(russianUTF16,(sizeof(russianUTF16)/2), "SCSU","russian",(char *)russianSCSU,sizeof(russianSCSU));
3772 TestConv(monkeyIn,(sizeof(monkeyIn)/2),"SCSU","monkey",NULL,0);
3773 }
3774
3775 #if !UCONFIG_NO_LEGACY_CONVERSION
3776 static void TestJitterbug2346(){
3777 char source[] = { 0x1b,0x24,0x42,0x3d,0x45,0x1b,0x28,0x4a,0x0d,0x0a,
3778 0x1b,0x24,0x42,0x3d,0x45,0x1b,0x28,0x4a,0x0d,0x0a};
3779 uint16_t expected[] = {0x91CD,0x000D,0x000A,0x91CD,0x000D,0x000A};
3780
3781 UChar uTarget[500]={'\0'};
3782 UChar* utarget=uTarget;
3783 UChar* utargetLimit=uTarget+sizeof(uTarget)/2;
3784
3785 char cTarget[500]={'\0'};
3786 char* ctarget=cTarget;
3787 char* ctargetLimit=cTarget+sizeof(cTarget);
3788 const char* csource=source;
3789 UChar* temp = expected;
3790 UErrorCode err=U_ZERO_ERROR;
3791
3792 UConverter* conv =ucnv_open("ISO_2022_JP",&err);
3793 if(U_FAILURE(err)) {
3794 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(err));
3795 return;
3796 }
3797 ucnv_toUnicode(conv,&utarget,utargetLimit,&csource,csource+sizeof(source),NULL,TRUE,&err);
3798 if(U_FAILURE(err)) {
3799 log_err("ISO_2022_JP to Unicode conversion failed: %s\n", u_errorName(err));
3800 return;
3801 }
3802 utargetLimit=utarget;
3803 utarget = uTarget;
3804 while(utarget<utargetLimit){
3805 if(*temp!=*utarget){
3806
3807 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*utarget,(int)*temp) ;
3808 }
3809 utarget++;
3810 temp++;
3811 }
3812 ucnv_fromUnicode(conv,&ctarget,ctargetLimit,(const UChar**)&utarget,utargetLimit,NULL,TRUE,&err);
3813 if(U_FAILURE(err)) {
3814 log_err("ISO_2022_JP from Unicode conversion failed: %s\n", u_errorName(err));
3815 return;
3816 }
3817 ctargetLimit=ctarget;
3818 ctarget =cTarget;
3819 ucnv_close(conv);
3820
3821
3822 }
3823
3824 static void
3825 TestISO_2022_JP_1() {
3826 /* test input */
3827 static const uint16_t in[]={
3828 0x3000, 0x3001, 0x3002, 0x0020, 0xFF0E, 0x30FB, 0xFF1A, 0xFF1B, 0x000D, 0x000A,
3829 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
3830 0x52C8, 0x52CC, 0x52CF, 0x52D1, 0x52D4, 0x52D6, 0x52DB, 0x52DC, 0x000D, 0x000A,
3831 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
3832 0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F, 0x005C, 0x000D, 0x000A,
3833 0x3013, 0x2018, 0x2026, 0x2025, 0x2018, 0x2019, 0x201C, 0x000D, 0x000A,
3834 0x201D, 0x000D, 0x000A,
3835 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3836 0x4F94, 0x4F97, 0x52BA, 0x52BB, 0x52BD, 0x52C0, 0x52C4, 0x52C6, 0x000D, 0x000A,
3837 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3838 0x4F78, 0x4F79, 0x4F7A, 0x4F7D, 0x4F7E, 0x4F81, 0x4F82, 0x4F84, 0x000D, 0x000A,
3839 0x4F85, 0x4F89, 0x4F8A, 0x4F8C, 0x4F8E, 0x4F90, 0x4F92, 0x4F93, 0x000D, 0x000A,
3840 0x52E1, 0x52E5, 0x52E8, 0x52E9, 0x000D, 0x000A
3841 };
3842 const UChar* uSource;
3843 const UChar* uSourceLimit;
3844 const char* cSource;
3845 const char* cSourceLimit;
3846 UChar *uTargetLimit =NULL;
3847 UChar *uTarget;
3848 char *cTarget;
3849 const char *cTargetLimit;
3850 char *cBuf;
3851 UChar *uBuf,*test;
3852 int32_t uBufSize = 120;
3853 UErrorCode errorCode=U_ZERO_ERROR;
3854 UConverter *cnv;
3855
3856 cnv=ucnv_open("ISO_2022_JP_1", &errorCode);
3857 if(U_FAILURE(errorCode)) {
3858 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
3859 return;
3860 }
3861
3862 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
3863 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
3864 uSource = (const UChar*)in;
3865 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
3866 cTarget = cBuf;
3867 cTargetLimit = cBuf +uBufSize*5;
3868 uTarget = uBuf;
3869 uTargetLimit = uBuf+ uBufSize*5;
3870 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,NULL,TRUE, &errorCode);
3871 if(U_FAILURE(errorCode)){
3872 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
3873 return;
3874 }
3875 cSource = cBuf;
3876 cSourceLimit =cTarget;
3877 test =uBuf;
3878 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,NULL,TRUE,&errorCode);
3879 if(U_FAILURE(errorCode)){
3880 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
3881 return;
3882 }
3883 uSource = (const UChar*)in;
3884 while(uSource<uSourceLimit){
3885 if(*test!=*uSource){
3886
3887 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
3888 }
3889 uSource++;
3890 test++;
3891 }
3892 /*ucnv_close(cnv);
3893 cnv=ucnv_open("ISO_2022,locale=jp,version=1", &errorCode);*/
3894 /*Test for the condition where there is an invalid character*/
3895 ucnv_reset(cnv);
3896 {
3897 static const uint8_t source2[]={0x0e,0x24,0x053};
3898 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-JP-1]");
3899 }
3900 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3901 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3902 ucnv_close(cnv);
3903 free(uBuf);
3904 free(cBuf);
3905 }
3906
3907 static void
3908 TestISO_2022_JP_2() {
3909 /* test input */
3910 static const uint16_t in[]={
3911 0x00A8, 0x3003, 0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x000D, 0x000A,
3912 0x2019, 0x201C, 0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x000D, 0x000A,
3913 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x000D, 0x000A,
3914 0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2236, 0x2227, 0x7FC1, 0x8956, 0x000D, 0x000A,
3915 0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x000D, 0x000A,
3916 0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x57F7, 0x000D, 0x000A,
3917 0x57F4, 0x57F9, 0x57FA, 0x57FC, 0x5800, 0x5802, 0x5805, 0x5806, 0x000D, 0x000A,
3918 0x580A, 0x581E, 0x6BB5, 0x6BB7, 0x6BBA, 0x6BBC, 0x9CE2, 0x977C, 0x000D, 0x000A,
3919 0x6BBF, 0x6BC1, 0x6BC5, 0x6BC6, 0x6BCB, 0x6BCD, 0x6BCF, 0x6BD2, 0x000D, 0x000A,
3920 0x6BD3, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6BDB, 0x6BEB, 0x6BEC, 0x000D, 0x000A,
3921 0x6C05, 0x6C08, 0x6C0F, 0x6C11, 0x6C13, 0x6C23, 0x6C34, 0x0041, 0x000D, 0x000A,
3922 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x000D, 0x000A,
3923 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x000D, 0x000A,
3924 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x000D, 0x000A,
3925 0x005B, 0x9792, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x000D, 0x000A,
3926 0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
3927 0x9785, 0x9791, 0x00BD, 0x0390, 0x0385, 0x0386, 0x0388, 0x0389, 0x000D, 0x000A,
3928 0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x000D, 0x000A,
3929 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x038A, 0x038C, 0x039C, 0x000D, 0x000A
3930 };
3931 const UChar* uSource;
3932 const UChar* uSourceLimit;
3933 const char* cSource;
3934 const char* cSourceLimit;
3935 UChar *uTargetLimit =NULL;
3936 UChar *uTarget;
3937 char *cTarget;
3938 const char *cTargetLimit;
3939 char *cBuf;
3940 UChar *uBuf,*test;
3941 int32_t uBufSize = 120;
3942 UErrorCode errorCode=U_ZERO_ERROR;
3943 UConverter *cnv;
3944 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
3945 int32_t* myOff= offsets;
3946 cnv=ucnv_open("ISO_2022_JP_2", &errorCode);
3947 if(U_FAILURE(errorCode)) {
3948 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
3949 return;
3950 }
3951
3952 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
3953 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
3954 uSource = (const UChar*)in;
3955 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
3956 cTarget = cBuf;
3957 cTargetLimit = cBuf +uBufSize*5;
3958 uTarget = uBuf;
3959 uTargetLimit = uBuf+ uBufSize*5;
3960 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
3961 if(U_FAILURE(errorCode)){
3962 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
3963 return;
3964 }
3965 cSource = cBuf;
3966 cSourceLimit =cTarget;
3967 test =uBuf;
3968 myOff=offsets;
3969 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
3970 if(U_FAILURE(errorCode)){
3971 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
3972 return;
3973 }
3974 uSource = (const UChar*)in;
3975 while(uSource<uSourceLimit){
3976 if(*test!=*uSource){
3977
3978 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
3979 }
3980 uSource++;
3981 test++;
3982 }
3983 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3984 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3985 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
3986 /*Test for the condition where there is an invalid character*/
3987 ucnv_reset(cnv);
3988 {
3989 static const uint8_t source2[]={0x0e,0x24,0x053};
3990 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-JP-2]");
3991 }
3992 ucnv_close(cnv);
3993 free(uBuf);
3994 free(cBuf);
3995 free(offsets);
3996 }
3997
3998 static void
3999 TestISO_2022_KR() {
4000 /* test input */
4001 static const uint16_t in[]={
4002 0x9F4B,0x9F4E,0x9F52,0x9F5F,0x9F61,0x9F67,0x9F6A,0x000A,0x000D
4003 ,0x9F6C,0x9F77,0x9F8D,0x9F90,0x9F95,0x9F9C,0xAC00,0xAC01,0xAC04
4004 ,0xAC07,0xAC08,0xAC09,0x0025,0x0026,0x0027,0x000A,0x000D,0x0028,0x0029
4005 ,0x002A,0x002B,0x002C,0x002D,0x002E,0x53C3,0x53C8,0x53C9,0x53CA,0x53CB
4006 ,0x53CD,0x53D4,0x53D6,0x53D7,0x53DB,0x000A,0x000D,0x53E1,0x53E2
4007 ,0x53E3,0x53E4,0x000A,0x000D};
4008 const UChar* uSource;
4009 const UChar* uSourceLimit;
4010 const char* cSource;
4011 const char* cSourceLimit;
4012 UChar *uTargetLimit =NULL;
4013 UChar *uTarget;
4014 char *cTarget;
4015 const char *cTargetLimit;
4016 char *cBuf;
4017 UChar *uBuf,*test;
4018 int32_t uBufSize = 120;
4019 UErrorCode errorCode=U_ZERO_ERROR;
4020 UConverter *cnv;
4021 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
4022 int32_t* myOff= offsets;
4023 cnv=ucnv_open("ISO_2022,locale=kr", &errorCode);
4024 if(U_FAILURE(errorCode)) {
4025 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
4026 return;
4027 }
4028
4029 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
4030 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
4031 uSource = (const UChar*)in;
4032 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
4033 cTarget = cBuf;
4034 cTargetLimit = cBuf +uBufSize*5;
4035 uTarget = uBuf;
4036 uTargetLimit = uBuf+ uBufSize*5;
4037 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
4038 if(U_FAILURE(errorCode)){
4039 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
4040 return;
4041 }
4042 cSource = cBuf;
4043 cSourceLimit =cTarget;
4044 test =uBuf;
4045 myOff=offsets;
4046 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
4047 if(U_FAILURE(errorCode)){
4048 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
4049 return;
4050 }
4051 uSource = (const UChar*)in;
4052 while(uSource<uSourceLimit){
4053 if(*test!=*uSource){
4054 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,*test) ;
4055 }
4056 uSource++;
4057 test++;
4058 }
4059 TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");
4060 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4061 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4062 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4063 TestJitterbug930("csISO2022KR");
4064 /*Test for the condition where there is an invalid character*/
4065 ucnv_reset(cnv);
4066 {
4067 static const uint8_t source2[]={0x1b,0x24,0x053};
4068 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
4069 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ILLEGAL_ESCAPE_SEQUENCE, "an invalid character [ISO-2022-KR]");
4070 }
4071 ucnv_close(cnv);
4072 free(uBuf);
4073 free(cBuf);
4074 free(offsets);
4075 }
4076
4077 static void
4078 TestISO_2022_KR_1() {
4079 /* test input */
4080 static const uint16_t in[]={
4081 0x9F4B,0x9F4E,0x9F52,0x9F5F,0x9F61,0x9F67,0x9F6A,0x000A,0x000D
4082 ,0x9F6C,0x9F77,0x9F8D,0x9F90,0x9F95,0x9F9C,0xAC00,0xAC01,0xAC04
4083 ,0xAC07,0xAC08,0xAC09,0x0025,0x0026,0x0027,0x000A,0x000D,0x0028,0x0029
4084 ,0x002A,0x002B,0x002C,0x002D,0x002E,0x53C3,0x53C8,0x53C9,0x53CA,0x53CB
4085 ,0x53CD,0x53D4,0x53D6,0x53D7,0x53DB,0x000A,0x000D,0x53E1,0x53E2
4086 ,0x53E3,0x53E4,0x000A,0x000D};
4087 const UChar* uSource;
4088 const UChar* uSourceLimit;
4089 const char* cSource;
4090 const char* cSourceLimit;
4091 UChar *uTargetLimit =NULL;
4092 UChar *uTarget;
4093 char *cTarget;
4094 const char *cTargetLimit;
4095 char *cBuf;
4096 UChar *uBuf,*test;
4097 int32_t uBufSize = 120;
4098 UErrorCode errorCode=U_ZERO_ERROR;
4099 UConverter *cnv;
4100 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
4101 int32_t* myOff= offsets;
4102 cnv=ucnv_open("ibm-25546", &errorCode);
4103 if(U_FAILURE(errorCode)) {
4104 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
4105 return;
4106 }
4107
4108 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
4109 cBuf =(char*)malloc(uBufSize * sizeof(char) * 5);
4110 uSource = (const UChar*)in;
4111 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
4112 cTarget = cBuf;
4113 cTargetLimit = cBuf +uBufSize*5;
4114 uTarget = uBuf;
4115 uTargetLimit = uBuf+ uBufSize*5;
4116 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
4117 if(U_FAILURE(errorCode)){
4118 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
4119 return;
4120 }
4121 cSource = cBuf;
4122 cSourceLimit =cTarget;
4123 test =uBuf;
4124 myOff=offsets;
4125 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
4126 if(U_FAILURE(errorCode)){
4127 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
4128 return;
4129 }
4130 uSource = (const UChar*)in;
4131 while(uSource<uSourceLimit){
4132 if(*test!=*uSource){
4133 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,*test) ;
4134 }
4135 uSource++;
4136 test++;
4137 }
4138 ucnv_reset(cnv);
4139 TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-KR encoding");
4140 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4141 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4142 ucnv_reset(cnv);
4143 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4144 /*Test for the condition where there is an invalid character*/
4145 ucnv_reset(cnv);
4146 {
4147 static const uint8_t source2[]={0x1b,0x24,0x053};
4148 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
4149 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ILLEGAL_ESCAPE_SEQUENCE, "an invalid character [ISO-2022-KR]");
4150 }
4151 ucnv_close(cnv);
4152 free(uBuf);
4153 free(cBuf);
4154 free(offsets);
4155 }
4156
4157 static void TestJitterbug2411(){
4158 static const char* source = "\x1b\x24\x29\x43\x6b\x6b\x6e\x6e\x6a\x68\x70\x6f\x69\x75\x79\x71\x77\x65\x68\x67\x0A"
4159 "\x1b\x24\x29\x43\x6a\x61\x73\x64\x66\x6a\x61\x73\x64\x66\x68\x6f\x69\x75\x79\x1b\x24\x29\x43";
4160 UConverter* kr=NULL, *kr1=NULL;
4161 UErrorCode errorCode = U_ZERO_ERROR;
4162 UChar tgt[100]={'\0'};
4163 UChar* target = tgt;
4164 UChar* targetLimit = target+100;
4165 kr=ucnv_open("iso-2022-kr", &errorCode);
4166 if(U_FAILURE(errorCode)) {
4167 log_data_err("Unable to open a iso-2022-kr converter: %s\n", u_errorName(errorCode));
4168 return;
4169 }
4170 ucnv_toUnicode(kr,&target,targetLimit,&source,source+uprv_strlen(source),NULL,TRUE,&errorCode);
4171 if(U_FAILURE(errorCode)) {
4172 log_err("iso-2022-kr cannot handle multiple escape sequences : %s\n", u_errorName(errorCode));
4173 return;
4174 }
4175 kr1 = ucnv_open("ibm-25546", &errorCode);
4176 if(U_FAILURE(errorCode)) {
4177 log_data_err("Unable to open a iso-2022-kr_1 converter: %s\n", u_errorName(errorCode));
4178 return;
4179 }
4180 target = tgt;
4181 targetLimit = target+100;
4182 ucnv_toUnicode(kr,&target,targetLimit,&source,source+uprv_strlen(source),NULL,TRUE,&errorCode);
4183
4184 if(U_FAILURE(errorCode)) {
4185 log_err("iso-2022-kr_1 cannot handle multiple escape sequences : %s\n", u_errorName(errorCode));
4186 return;
4187 }
4188
4189 ucnv_close(kr);
4190 ucnv_close(kr1);
4191
4192 }
4193
4194 static void
4195 TestJIS(){
4196 /* From Unicode moved to testdata/conversion.txt */
4197 /*To Unicode*/
4198 {
4199 static const uint8_t sampleTextJIS[] = {
4200 0x1b,0x28,0x48,0x41,0x42, /*jis-Roman*/
4201 0x1b,0x28,0x49,0x41,0x42, /*Katakana Set*/
4202 0x1b,0x26,0x40,0x1b,0x24,0x42,0x21,0x21 /*recognize and ignore <esc>&@*/
4203 };
4204 static const uint16_t expectedISO2022JIS[] = {
4205 0x0041, 0x0042,
4206 0xFF81, 0xFF82,
4207 0x3000
4208 };
4209 static const int32_t toISO2022JISOffs[]={
4210 3,4,
4211 8,9,
4212 16
4213 };
4214
4215 static const uint8_t sampleTextJIS7[] = {
4216 0x1b,0x28,0x48,0x41,0x42, /*JIS7-Roman*/
4217 0x1b,0x28,0x49,0x41,0x42, /*Katakana Set*/
4218 0x1b,0x24,0x42,0x21,0x21,
4219 0x0e,0x41,0x42,0x0f, /*Test Katakana set with SI and SO */
4220 0x21,0x22,
4221 0x1b,0x26,0x40,0x1b,0x24,0x42,0x21,0x21 /*recognize and ignore <esc>&@*/
4222 };
4223 static const uint16_t expectedISO2022JIS7[] = {
4224 0x0041, 0x0042,
4225 0xFF81, 0xFF82,
4226 0x3000,
4227 0xFF81, 0xFF82,
4228 0x3001,
4229 0x3000
4230 };
4231 static const int32_t toISO2022JIS7Offs[]={
4232 3,4,
4233 8,9,
4234 13,16,
4235 17,
4236 19,27
4237 };
4238 static const uint8_t sampleTextJIS8[] = {
4239 0x1b,0x28,0x48,0x41,0x42, /*JIS8-Roman*/
4240 0xa1,0xc8,0xd9,/*Katakana Set*/
4241 0x1b,0x28,0x42,
4242 0x41,0x42,
4243 0xb1,0xc3, /*Katakana Set*/
4244 0x1b,0x24,0x42,0x21,0x21
4245 };
4246 static const uint16_t expectedISO2022JIS8[] = {
4247 0x0041, 0x0042,
4248 0xff61, 0xff88, 0xff99,
4249 0x0041, 0x0042,
4250 0xff71, 0xff83,
4251 0x3000
4252 };
4253 static const int32_t toISO2022JIS8Offs[]={
4254 3, 4, 5, 6,
4255 7, 11, 12, 13,
4256 14, 18,
4257 };
4258
4259 testConvertToU(sampleTextJIS,sizeof(sampleTextJIS),expectedISO2022JIS,
4260 UPRV_LENGTHOF(expectedISO2022JIS),"JIS", toISO2022JISOffs,TRUE);
4261 testConvertToU(sampleTextJIS7,sizeof(sampleTextJIS7),expectedISO2022JIS7,
4262 UPRV_LENGTHOF(expectedISO2022JIS7),"JIS7", toISO2022JIS7Offs,TRUE);
4263 testConvertToU(sampleTextJIS8,sizeof(sampleTextJIS8),expectedISO2022JIS8,
4264 UPRV_LENGTHOF(expectedISO2022JIS8),"JIS8", toISO2022JIS8Offs,TRUE);
4265 }
4266
4267 }
4268
4269
4270 #if 0
4271 ICU 4.4 (ticket #7314) removes mappings for CNS 11643 planes 3..7
4272
4273 static void TestJitterbug915(){
4274 /* tests for roundtripping of the below sequence
4275 \x1b$)G\x0E#!#"###$#%#&#'#(#)#*#+ / *plane 1 * /
4276 \x1b$*H\x1bN"!\x1bN""\x1bN"#\x1bN"$\x1bN"% / *plane 2 * /
4277 \x1b$+I\x1bO"D\x1bO"E\x1bO"F\x1bO"G\x1bO"H / *plane 3 * /
4278 \x1b$+J\x1bO!D\x1bO!E\x1bO"j\x1bO"k\x1bO"l / *plane 4 * /
4279 \x1b$+K\x1bO!t\x1bO"P\x1bO"Q\x1bO#7\x1bO"\ / *plane 5 * /
4280 \x1b$+L\x1bO!#\x1bO",\x1bO#N\x1bO!n\x1bO#q / *plane 6 * /
4281 \x1b$+M\x1bO"q\x1bO!N\x1bO!j\x1bO#:\x1bO#o / *plane 7 * /
4282 */
4283 static const char cSource[]={
4284 0x1B, 0x24, 0x29, 0x47, 0x0E, 0x23, 0x21, 0x23, 0x22, 0x23,
4285 0x23, 0x23, 0x24, 0x23, 0x25, 0x23, 0x26, 0x23, 0x27, 0x23,
4286 0x28, 0x23, 0x29, 0x23, 0x2A, 0x23, 0x2B, 0x0F, 0x2F, 0x2A,
4287 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20, 0x31, 0x20, 0x2A, 0x2F,
4288 0x0D, 0x0A, 0x1B, 0x24, 0x2A, 0x48, 0x1B, 0x4E, 0x22, 0x21,
4289 0x1B, 0x4E, 0x22, 0x22, 0x1B, 0x4E, 0x22, 0x23, 0x1B, 0x4E,
4290 0x22, 0x24, 0x1B, 0x4E, 0x22, 0x25, 0x2F, 0x2A, 0x70,
4291 0x6C, 0x61, 0x6E, 0x65, 0x32, 0x2A, 0x2F, 0x20, 0x0D, 0x0A,
4292 0x1B, 0x24, 0x2B, 0x49, 0x1B, 0x4F, 0x22, 0x44, 0x1B, 0x4F,
4293 0x22, 0x45, 0x1B, 0x4F, 0x22, 0x46, 0x1B, 0x4F, 0x22, 0x47,
4294 0x1B, 0x4F, 0x22, 0x48, 0x2F, 0x2A, 0x70, 0x6C, 0x61,
4295 0x6E, 0x65, 0x20, 0x33, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B,
4296 0x24, 0x2B, 0x4A, 0x1B, 0x4F, 0x21, 0x44, 0x1B, 0x4F, 0x21,
4297 0x45, 0x1B, 0x4F, 0x22, 0x6A, 0x1B, 0x4F, 0x22, 0x6B, 0x1B,
4298 0x4F, 0x22, 0x6C, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
4299 0x65, 0x20, 0x34, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
4300 0x2B, 0x4B, 0x1B, 0x4F, 0x21, 0x74, 0x1B, 0x4F, 0x22, 0x50,
4301 0x1B, 0x4F, 0x22, 0x51, 0x1B, 0x4F, 0x23, 0x37, 0x1B, 0x4F,
4302 0x22, 0x5C, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E,
4303 0x65, 0x20, 0x35, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24,
4304 0x2B, 0x4C, 0x1B, 0x4F, 0x21, 0x23, 0x1B, 0x4F, 0x22, 0x2C,
4305 0x1B, 0x4F, 0x23, 0x4E, 0x1B, 0x4F, 0x21, 0x6E, 0x1B, 0x4F,
4306 0x23, 0x71, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65,
4307 0x20, 0x36, 0x20, 0x2A, 0x2F, 0x0D, 0x0A, 0x1B, 0x24, 0x2B,
4308 0x4D, 0x1B, 0x4F, 0x22, 0x71, 0x1B, 0x4F, 0x21, 0x4E, 0x1B,
4309 0x4F, 0x21, 0x6A, 0x1B, 0x4F, 0x23, 0x3A, 0x1B, 0x4F, 0x23,
4310 0x6F, 0x2F, 0x2A, 0x70, 0x6C, 0x61, 0x6E, 0x65, 0x20,
4311 0x37, 0x20, 0x2A, 0x2F
4312 };
4313 UChar uTarget[500]={'\0'};
4314 UChar* utarget=uTarget;
4315 UChar* utargetLimit=uTarget+sizeof(uTarget)/2;
4316
4317 char cTarget[500]={'\0'};
4318 char* ctarget=cTarget;
4319 char* ctargetLimit=cTarget+sizeof(cTarget);
4320 const char* csource=cSource;
4321 const char* tempSrc = cSource;
4322 UErrorCode err=U_ZERO_ERROR;
4323
4324 UConverter* conv =ucnv_open("ISO_2022_CN_EXT",&err);
4325 if(U_FAILURE(err)) {
4326 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(err));
4327 return;
4328 }
4329 ucnv_toUnicode(conv,&utarget,utargetLimit,&csource,csource+sizeof(cSource),NULL,TRUE,&err);
4330 if(U_FAILURE(err)) {
4331 log_err("iso-2022-CN to Unicode conversion failed: %s\n", u_errorName(err));
4332 return;
4333 }
4334 utargetLimit=utarget;
4335 utarget = uTarget;
4336 ucnv_fromUnicode(conv,&ctarget,ctargetLimit,(const UChar**)&utarget,utargetLimit,NULL,TRUE,&err);
4337 if(U_FAILURE(err)) {
4338 log_err("iso-2022-CN from Unicode conversion failed: %s\n", u_errorName(err));
4339 return;
4340 }
4341 ctargetLimit=ctarget;
4342 ctarget =cTarget;
4343 while(ctarget<ctargetLimit){
4344 if(*ctarget != *tempSrc){
4345 log_err("j915[%d] Expected : \\x%02X \t Got: \\x%02X\n", (int)(ctarget-cTarget), *ctarget,(int)*tempSrc) ;
4346 }
4347 ++ctarget;
4348 ++tempSrc;
4349 }
4350
4351 ucnv_close(conv);
4352 }
4353
4354 static void
4355 TestISO_2022_CN_EXT() {
4356 /* test input */
4357 static const uint16_t in[]={
4358 /* test Non-BMP code points */
4359 0xD869, 0xDE99, 0xD869, 0xDE9C, 0xD869, 0xDE9D, 0xD869, 0xDE9E, 0xD869, 0xDE9F,
4360 0xD869, 0xDEA0, 0xD869, 0xDEA5, 0xD869, 0xDEA6, 0xD869, 0xDEA7, 0xD869, 0xDEA8,
4361 0xD869, 0xDEAB, 0xD869, 0xDEAC, 0xD869, 0xDEAD, 0xD869, 0xDEAE, 0xD869, 0xDEAF,
4362 0xD869, 0xDEB0, 0xD869, 0xDEB1, 0xD869, 0xDEB3, 0xD869, 0xDEB5, 0xD869, 0xDEB6,
4363 0xD869, 0xDEB7, 0xD869, 0xDEB8, 0xD869, 0xDEB9, 0xD869, 0xDEBA, 0xD869, 0xDEBB,
4364 0xD869, 0xDEBC, 0xD869, 0xDEBD, 0xD869, 0xDEBE, 0xD869, 0xDEBF, 0xD869, 0xDEC0,
4365 0xD869, 0xDEC1, 0xD869, 0xDEC2, 0xD869, 0xDEC3, 0xD869, 0xDEC4, 0xD869, 0xDEC8,
4366 0xD869, 0xDECA, 0xD869, 0xDECB, 0xD869, 0xDECD, 0xD869, 0xDECE, 0xD869, 0xDECF,
4367 0xD869, 0xDED0, 0xD869, 0xDED1, 0xD869, 0xDED2, 0xD869, 0xDED3, 0xD869, 0xDED4,
4368 0xD869, 0xDED5,
4369
4370 0x4DB3, 0x4DB4, 0x4DB5, 0x4E00, 0x4E00, 0x4E01, 0x4E02, 0x4E03, 0x000D, 0x000A,
4371 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x33E0, 0x33E6, 0x000D, 0x000A,
4372 0x4E05, 0x4E07, 0x4E04, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x000D, 0x000A,
4373 0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
4374 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,
4375 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0x6332, 0x63B0, 0x643F, 0x000D, 0x000A,
4376 0x64D8, 0x8004, 0x6BEA, 0x6BF3, 0x6BFD, 0x6BF5, 0x6BF9, 0x6C05, 0x000D, 0x000A,
4377 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x000D, 0x000A,
4378 0x6C07, 0x6C06, 0x6C0D, 0x6C15, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
4379 0x9CE2, 0x977C, 0x9785, 0x9791, 0x9792, 0x9794, 0x97AF, 0x97AB, 0x000D, 0x000A,
4380 0x97A3, 0x97B2, 0x97B4, 0x9AB1, 0x9AB0, 0x9AB7, 0x9E58, 0x9AB6, 0x000D, 0x000A,
4381 0x9ABA, 0x9ABC, 0x9AC1, 0x9AC0, 0x9AC5, 0x9AC2, 0x9ACB, 0x9ACC, 0x000D, 0x000A,
4382 0x9AD1, 0x9B45, 0x9B43, 0x9B47, 0x9B49, 0x9B48, 0x9B4D, 0x9B51, 0x000D, 0x000A,
4383 0x98E8, 0x990D, 0x992E, 0x9955, 0x9954, 0x9ADF, 0x3443, 0x3444, 0x000D, 0x000A,
4384 0x3445, 0x3449, 0x344A, 0x344B, 0x60F2, 0x60F3, 0x60F4, 0x60F5, 0x000D, 0x000A,
4385 0x60F6, 0x60F7, 0x60F8, 0x60F9, 0x60FA, 0x60FB, 0x60FC, 0x60FD, 0x000D, 0x000A,
4386 0x60FE, 0x60FF, 0x6100, 0x6101, 0x6102, 0x0041, 0x0042, 0x0043, 0x000D, 0x000A,
4387 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x000D, 0x000A,
4388
4389 0x33E7, 0x33E8, 0x33E9, 0x33EA, 0x000D, 0x000A
4390
4391 };
4392
4393 const UChar* uSource;
4394 const UChar* uSourceLimit;
4395 const char* cSource;
4396 const char* cSourceLimit;
4397 UChar *uTargetLimit =NULL;
4398 UChar *uTarget;
4399 char *cTarget;
4400 const char *cTargetLimit;
4401 char *cBuf;
4402 UChar *uBuf,*test;
4403 int32_t uBufSize = 180;
4404 UErrorCode errorCode=U_ZERO_ERROR;
4405 UConverter *cnv;
4406 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
4407 int32_t* myOff= offsets;
4408 cnv=ucnv_open("ISO_2022,locale=cn,version=1", &errorCode);
4409 if(U_FAILURE(errorCode)) {
4410 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
4411 return;
4412 }
4413
4414 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
4415 cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
4416 uSource = (const UChar*)in;
4417 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
4418 cTarget = cBuf;
4419 cTargetLimit = cBuf +uBufSize*5;
4420 uTarget = uBuf;
4421 uTargetLimit = uBuf+ uBufSize*5;
4422 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
4423 if(U_FAILURE(errorCode)){
4424 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
4425 return;
4426 }
4427 cSource = cBuf;
4428 cSourceLimit =cTarget;
4429 test =uBuf;
4430 myOff=offsets;
4431 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
4432 if(U_FAILURE(errorCode)){
4433 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
4434 return;
4435 }
4436 uSource = (const UChar*)in;
4437 while(uSource<uSourceLimit){
4438 if(*test!=*uSource){
4439 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
4440 }
4441 else{
4442 log_verbose(" Got: \\u%04X\n",(int)*test) ;
4443 }
4444 uSource++;
4445 test++;
4446 }
4447 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4448 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4449 /*Test for the condition where there is an invalid character*/
4450 ucnv_reset(cnv);
4451 {
4452 static const uint8_t source2[]={0x0e,0x24,0x053};
4453 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-CN-EXT]");
4454 }
4455 ucnv_close(cnv);
4456 free(uBuf);
4457 free(cBuf);
4458 free(offsets);
4459 }
4460 #endif
4461
4462 static void
4463 TestISO_2022_CN() {
4464 /* test input */
4465 static const uint16_t in[]={
4466 /* jitterbug 951 */
4467 0xFF2D, 0xFF49, 0xFF58, 0xFF45, 0xFF44, 0x0020, 0xFF43, 0xFF48, 0xFF41, 0xFF52,
4468 0x0020, 0xFF06, 0x0020, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17,
4469 0xFF18, 0xFF19, 0xFF10, 0x0020, 0xFF4E, 0xFF55, 0xFF4D, 0xFF42, 0xFF45, 0xFF52,
4470 0x0020, 0xFF54, 0xFF45, 0xFF53, 0xFF54, 0x0020, 0xFF4C, 0xFF49, 0xFF4E, 0xFF45,
4471 0x0020, 0x0045, 0x004e, 0x0044,
4472 /**/
4473 0x4E00, 0x4E00, 0x4E01, 0x4E03, 0x60F6, 0x60F7, 0x60F8, 0x60FB, 0x000D, 0x000A,
4474 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x60FB, 0x60FC, 0x000D, 0x000A,
4475 0x4E07, 0x4E08, 0x4E08, 0x4E09, 0x4E0A, 0x4E0B, 0x0042, 0x0043, 0x000D, 0x000A,
4476 0x4E0C, 0x0021, 0x0022, 0x0023, 0x0024, 0xFF40, 0xFF41, 0xFF42, 0x000D, 0x000A,
4477 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0x000D, 0x000A,
4478 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0x6332, 0x63B0, 0x643F, 0x000D, 0x000A,
4479 0x64D8, 0x8004, 0x6BEA, 0x6BF3, 0x6BFD, 0x6BF5, 0x6BF9, 0x6C05, 0x000D, 0x000A,
4480 0x6C07, 0x6C06, 0x6C0D, 0x6C15, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x000D, 0x000A,
4481 0x9CE2, 0x977C, 0x9785, 0x9791, 0x9792, 0x9794, 0x97AF, 0x97AB, 0x000D, 0x000A,
4482 0x97A3, 0x97B2, 0x97B4, 0x9AB1, 0x9AB0, 0x9AB7, 0x9E58, 0x9AB6, 0x000D, 0x000A,
4483 0x9ABA, 0x9ABC, 0x9AC1, 0x9AC0, 0x9AC5, 0x9AC2, 0x9ACB, 0x9ACC, 0x000D, 0x000A,
4484 0x9AD1, 0x9B45, 0x9B43, 0x9B47, 0x9B49, 0x9B48, 0x9B4D, 0x9B51, 0x000D, 0x000A,
4485 0x98E8, 0x990D, 0x992E, 0x9955, 0x9954, 0x9ADF, 0x60FE, 0x60FF, 0x000D, 0x000A,
4486 0x60F2, 0x60F3, 0x60F4, 0x60F5, 0x000D, 0x000A, 0x60F9, 0x60FA, 0x000D, 0x000A,
4487 0x6100, 0x6101, 0x0041, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x000D, 0x000A,
4488 0x247D, 0x247E, 0x247F, 0x2480, 0x2481, 0x2482, 0x2483, 0x2484, 0x2485, 0x2486,
4489 0x2487, 0x2460, 0x2461, 0xFF20, 0xFF21, 0xFF22, 0x0049, 0x004A, 0x000D, 0x000A,
4490
4491 };
4492 const UChar* uSource;
4493 const UChar* uSourceLimit;
4494 const char* cSource;
4495 const char* cSourceLimit;
4496 UChar *uTargetLimit =NULL;
4497 UChar *uTarget;
4498 char *cTarget;
4499 const char *cTargetLimit;
4500 char *cBuf;
4501 UChar *uBuf,*test;
4502 int32_t uBufSize = 180;
4503 UErrorCode errorCode=U_ZERO_ERROR;
4504 UConverter *cnv;
4505 int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) * 5);
4506 int32_t* myOff= offsets;
4507 cnv=ucnv_open("ISO_2022,locale=cn,version=0", &errorCode);
4508 if(U_FAILURE(errorCode)) {
4509 log_data_err("Unable to open a iso-2022 converter: %s\n", u_errorName(errorCode));
4510 return;
4511 }
4512
4513 uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
4514 cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
4515 uSource = (const UChar*)in;
4516 uSourceLimit=(const UChar*)in + UPRV_LENGTHOF(in);
4517 cTarget = cBuf;
4518 cTargetLimit = cBuf +uBufSize*5;
4519 uTarget = uBuf;
4520 uTargetLimit = uBuf+ uBufSize*5;
4521 ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&uSource,uSourceLimit,myOff,TRUE, &errorCode);
4522 if(U_FAILURE(errorCode)){
4523 log_err("ucnv_fromUnicode conversion failed reason %s\n", u_errorName(errorCode));
4524 return;
4525 }
4526 cSource = cBuf;
4527 cSourceLimit =cTarget;
4528 test =uBuf;
4529 myOff=offsets;
4530 ucnv_toUnicode(cnv,&uTarget,uTargetLimit,&cSource,cSourceLimit,myOff,TRUE,&errorCode);
4531 if(U_FAILURE(errorCode)){
4532 log_err("ucnv_toUnicode conversion failed reason %s\n", u_errorName(errorCode));
4533 return;
4534 }
4535 uSource = (const UChar*)in;
4536 while(uSource<uSourceLimit){
4537 if(*test!=*uSource){
4538 log_err("Expected : \\u%04X \t Got: \\u%04X\n",*uSource,(int)*test) ;
4539 }
4540 else{
4541 log_verbose(" Got: \\u%04X\n",(int)*test) ;
4542 }
4543 uSource++;
4544 test++;
4545 }
4546 TestGetNextUChar2022(cnv, cBuf, cTarget, in, "ISO-2022-CN encoding");
4547 TestSmallTargetBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4548 TestSmallSourceBuffer(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4549 TestToAndFromUChars(in,(const UChar*)in + UPRV_LENGTHOF(in),cnv);
4550 TestJitterbug930("csISO2022CN");
4551 /*Test for the condition where there is an invalid character*/
4552 ucnv_reset(cnv);
4553 {
4554 static const uint8_t source2[]={0x0e,0x24,0x053};
4555 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [ISO-2022-CN]");
4556 }
4557
4558 ucnv_close(cnv);
4559 free(uBuf);
4560 free(cBuf);
4561 free(offsets);
4562 }
4563
4564 /* Tests for empty segments in ISO-2022-JP/KR/CN, HZ, check that UConverterCallbackReason is UCNV_IRREGULAR */
4565 typedef struct {
4566 const char * converterName;
4567 const char * inputText;
4568 int inputTextLength;
4569 } EmptySegmentTest;
4570
4571 /* Callback for TestJitterbug6175, should only get called for empty segment errors */
4572 static void UCNV_TO_U_CALLBACK_EMPTYSEGMENT( const void *context, UConverterToUnicodeArgs *toArgs, const char* codeUnits,
4573 int32_t length, UConverterCallbackReason reason, UErrorCode * err ) {
4574 if (reason > UCNV_IRREGULAR) {
4575 return;
4576 }
4577 if (reason != UCNV_IRREGULAR) {
4578 log_err("toUnicode callback invoked for empty segment but reason is not UCNV_IRREGULAR\n");
4579 }
4580 /* Standard stuff below from UCNV_TO_U_CALLBACK_SUBSTITUTE */
4581 *err = U_ZERO_ERROR;
4582 ucnv_cbToUWriteSub(toArgs,0,err);
4583 }
4584
4585 enum { kEmptySegmentToUCharsMax = 64 };
4586 static void TestJitterbug6175(void) {
4587 static const char iso2022jp_a[] = { 0x61, 0x62, 0x1B,0x24,0x42, 0x1B,0x28,0x42, 0x63, 0x64, 0x0D, 0x0A };
4588 static const char iso2022kr_a[] = { 0x1B,0x24,0x29,0x43, 0x61, 0x0E, 0x0F, 0x62, 0x0D, 0x0A };
4589 static const char iso2022cn_a[] = { 0x61, 0x1B,0x24,0x29,0x41, 0x62, 0x0E, 0x0F, 0x1B,0x24,0x2A,0x48, 0x1B,0x4E, 0x6A,0x65, 0x63, 0x0D, 0x0A };
4590 static const char iso2022cn_b[] = { 0x61, 0x1B,0x24,0x29,0x41, 0x62, 0x0E, 0x1B,0x24,0x29,0x47, 0x68,0x64, 0x0F, 0x63, 0x0D, 0x0A };
4591 static const char hzGB2312_a[] = { 0x61, 0x62, 0x7E,0x7B, 0x7E,0x7D, 0x63, 0x64 };
4592 static const EmptySegmentTest emptySegmentTests[] = {
4593 /* converterName inputText inputTextLength */
4594 { "ISO-2022-JP", iso2022jp_a, sizeof(iso2022jp_a) },
4595 { "ISO-2022-KR", iso2022kr_a, sizeof(iso2022kr_a) },
4596 { "ISO-2022-CN", iso2022cn_a, sizeof(iso2022cn_a) },
4597 { "ISO-2022-CN", iso2022cn_b, sizeof(iso2022cn_b) },
4598 { "HZ-GB-2312", hzGB2312_a, sizeof(hzGB2312_a) },
4599 /* terminator: */
4600 { NULL, NULL, 0, }
4601 };
4602 const EmptySegmentTest * testPtr;
4603 for (testPtr = emptySegmentTests; testPtr->converterName != NULL; ++testPtr) {
4604 UErrorCode err = U_ZERO_ERROR;
4605 UConverter * cnv = ucnv_open(testPtr->converterName, &err);
4606 if (U_FAILURE(err)) {
4607 log_data_err("Unable to open %s converter: %s\n", testPtr->converterName, u_errorName(err));
4608 return;
4609 }
4610 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_EMPTYSEGMENT, NULL, NULL, NULL, &err);
4611 if (U_FAILURE(err)) {
4612 log_data_err("Unable to setToUCallBack for %s converter: %s\n", testPtr->converterName, u_errorName(err));
4613 ucnv_close(cnv);
4614 return;
4615 }
4616 {
4617 UChar toUChars[kEmptySegmentToUCharsMax];
4618 UChar * toUCharsPtr = toUChars;
4619 const UChar * toUCharsLimit = toUCharsPtr + kEmptySegmentToUCharsMax;
4620 const char * inCharsPtr = testPtr->inputText;
4621 const char * inCharsLimit = inCharsPtr + testPtr->inputTextLength;
4622 ucnv_toUnicode(cnv, &toUCharsPtr, toUCharsLimit, &inCharsPtr, inCharsLimit, NULL, TRUE, &err);
4623 }
4624 ucnv_close(cnv);
4625 }
4626 }
4627
4628 static void
4629 TestEBCDIC_STATEFUL() {
4630 /* test input */
4631 static const uint8_t in[]={
4632 0x61,
4633 0x1a,
4634 0x0f, 0x4b,
4635 0x42,
4636 0x40,
4637 0x36,
4638 };
4639
4640 /* expected test results */
4641 static const int32_t results[]={
4642 /* number of bytes read, code point */
4643 1, 0x002f,
4644 1, 0x0092,
4645 2, 0x002e,
4646 1, 0xff62,
4647 1, 0x0020,
4648 1, 0x0096,
4649
4650 };
4651 static const uint8_t in2[]={
4652 0x0f,
4653 0xa1,
4654 0x01
4655 };
4656
4657 /* expected test results */
4658 static const int32_t results2[]={
4659 /* number of bytes read, code point */
4660 2, 0x203E,
4661 1, 0x0001,
4662 };
4663
4664 const char *source=(const char *)in, *limit=(const char *)in+sizeof(in);
4665 UErrorCode errorCode=U_ZERO_ERROR;
4666 UConverter *cnv=ucnv_open("ibm-930", &errorCode);
4667 if(U_FAILURE(errorCode)) {
4668 log_data_err("Unable to open a EBCDIC_STATEFUL(ibm-930) converter: %s\n", u_errorName(errorCode));
4669 return;
4670 }
4671 TestNextUChar(cnv, source, limit, results, "EBCDIC_STATEFUL(ibm-930)");
4672 ucnv_reset(cnv);
4673 /* Test the condition when source >= sourceLimit */
4674 TestNextUCharError(cnv, source, source, U_INDEX_OUTOFBOUNDS_ERROR, "sourceLimit <= source");
4675 ucnv_reset(cnv);
4676 /*Test for the condition where source > sourcelimit after consuming the shift chracter */
4677 {
4678 static const uint8_t source1[]={0x0f};
4679 TestNextUCharError(cnv, (const char*)source1, (const char*)source1+sizeof(source1), U_INDEX_OUTOFBOUNDS_ERROR, "a character is truncated");
4680 }
4681 /*Test for the condition where there is an invalid character*/
4682 ucnv_reset(cnv);
4683 {
4684 static const uint8_t source2[]={0x0e, 0x7F, 0xFF};
4685 TestNextUCharError(cnv, (const char*)source2, (const char*)source2+sizeof(source2), U_ZERO_ERROR, "an invalid character [EBCDIC STATEFUL]");
4686 }
4687 ucnv_reset(cnv);
4688 source=(const char*)in2;
4689 limit=(const char*)in2+sizeof(in2);
4690 TestNextUChar(cnv,source,limit,results2,"EBCDIC_STATEFUL(ibm-930),seq#2");
4691 ucnv_close(cnv);
4692
4693 }
4694
4695 static void
4696 TestGB18030() {
4697 /* test input */
4698 static const uint8_t in[]={
4699 0x24,
4700 0x7f,
4701 0x81, 0x30, 0x81, 0x30,
4702 0xa8, 0xbf,
4703 0xa2, 0xe3,
4704 0xd2, 0xbb,
4705 0x82, 0x35, 0x8f, 0x33,
4706 0x84, 0x31, 0xa4, 0x39,
4707 0x90, 0x30, 0x81, 0x30,
4708 0xe3, 0x32, 0x9a, 0x35
4709 #if 0
4710 /*
4711 * Feature removed markus 2000-oct-26
4712 * Only some codepages must match surrogate pairs into supplementary code points -
4713 * see javadoc for ucnv_getNextUChar() and implementation notes in ucnvmbcs.c .
4714 * GB 18030 provides direct encodings for supplementary code points, therefore
4715 * it must not combine two single-encoded surrogates into one code point.
4716 */
4717 0x83, 0x36, 0xc8, 0x30, 0x83, 0x37, 0xb0, 0x34 /* separately encoded surrogates */
4718 #endif
4719 };
4720
4721 /* expected test results */
4722 static const int32_t results[]={
4723 /* number of bytes read, code point */
4724 1, 0x24,
4725 1, 0x7f,
4726 4, 0x80,
4727 2, 0x1f9,
4728 2, 0x20ac,
4729 2, 0x4e00,
4730 4, 0x9fa6,
4731 4, 0xffff,
4732 4, 0x10000,
4733 4, 0x10ffff
4734 #if 0
4735 /* Feature removed. See comment above. */
4736 8, 0x10000
4737 #endif
4738 };
4739
4740 /* const char *source=(const char *)in,*limit=(const char *)in+sizeof(in); */
4741 UErrorCode errorCode=U_ZERO_ERROR;
4742 UConverter *cnv=ucnv_open("gb18030", &errorCode);
4743 if(U_FAILURE(errorCode)) {
4744 log_data_err("Unable to open a gb18030 converter: %s\n", u_errorName(errorCode));
4745 return;
4746 }
4747 TestNextUChar(cnv, (const char *)in, (const char *)in+sizeof(in), results, "gb18030");
4748 ucnv_close(cnv);
4749 }
4750
4751 static void
4752 TestLMBCS() {
4753 /* LMBCS-1 string */
4754 static const uint8_t pszLMBCS[]={
4755 0x61,
4756 0x01, 0x29,
4757 0x81,
4758 0xA0,
4759 0x0F, 0x27,
4760 0x0F, 0x91,
4761 0x14, 0x0a, 0x74,
4762 0x14, 0xF6, 0x02,
4763 0x14, 0xd8, 0x4d, 0x14, 0xdc, 0x56, /* UTF-16 surrogate pair */
4764 0x10, 0x88, 0xA0,
4765 };
4766
4767 /* Unicode UChar32 equivalents */
4768 static const UChar32 pszUnicode32[]={
4769 /* code point */
4770 0x00000061,
4771 0x00002013,
4772 0x000000FC,
4773 0x000000E1,
4774 0x00000007,
4775 0x00000091,
4776 0x00000a74,
4777 0x00000200,
4778 0x00023456, /* code point for surrogate pair */
4779 0x00005516
4780 };
4781
4782 /* Unicode UChar equivalents */
4783 static const UChar pszUnicode[]={
4784 /* code point */
4785 0x0061,
4786 0x2013,
4787 0x00FC,
4788 0x00E1,
4789 0x0007,
4790 0x0091,
4791 0x0a74,
4792 0x0200,
4793 0xD84D, /* low surrogate */
4794 0xDC56, /* high surrogate */
4795 0x5516
4796 };
4797
4798 /* expected test results */
4799 static const int offsets32[]={
4800 /* number of bytes read, code point */
4801 0,
4802 1,
4803 3,
4804 4,
4805 5,
4806 7,
4807 9,
4808 12,
4809 15,
4810 21,
4811 24
4812 };
4813
4814 /* expected test results */
4815 static const int offsets[]={
4816 /* number of bytes read, code point */
4817 0,
4818 1,
4819 3,
4820 4,
4821 5,
4822 7,
4823 9,
4824 12,
4825 15,
4826 18,
4827 21,
4828 24
4829 };
4830
4831
4832 UConverter *cnv;
4833
4834 #define NAME_LMBCS_1 "LMBCS-1"
4835 #define NAME_LMBCS_2 "LMBCS-2"
4836
4837
4838 /* Some basic open/close/property tests on some LMBCS converters */
4839 {
4840
4841 char expected_subchars[] = {0x3F}; /* ANSI Question Mark */
4842 char new_subchars [] = {0x7F}; /* subst char used by SmartSuite..*/
4843 char get_subchars [1];
4844 const char * get_name;
4845 UConverter *cnv1;
4846 UConverter *cnv2;
4847
4848 int8_t len = sizeof(get_subchars);
4849
4850 UErrorCode errorCode=U_ZERO_ERROR;
4851
4852 /* Open */
4853 cnv1=ucnv_open(NAME_LMBCS_1, &errorCode);
4854 if(U_FAILURE(errorCode)) {
4855 log_data_err("Unable to open a LMBCS-1 converter: %s\n", u_errorName(errorCode));
4856 return;
4857 }
4858 cnv2=ucnv_open(NAME_LMBCS_2, &errorCode);
4859 if(U_FAILURE(errorCode)) {
4860 log_data_err("Unable to open a LMBCS-2 converter: %s\n", u_errorName(errorCode));
4861 return;
4862 }
4863
4864 /* Name */
4865 get_name = ucnv_getName (cnv1, &errorCode);
4866 if (strcmp(NAME_LMBCS_1,get_name)){
4867 log_err("Unexpected converter name: %s\n", get_name);
4868 }
4869 get_name = ucnv_getName (cnv2, &errorCode);
4870 if (strcmp(NAME_LMBCS_2,get_name)){
4871 log_err("Unexpected converter name: %s\n", get_name);
4872 }
4873
4874 /* substitution chars */
4875 ucnv_getSubstChars (cnv1, get_subchars, &len, &errorCode);
4876 if(U_FAILURE(errorCode)) {
4877 log_err("Failure on get subst chars: %s\n", u_errorName(errorCode));
4878 }
4879 if (len!=1){
4880 log_err("Unexpected length of sub chars\n");
4881 }
4882 if (get_subchars[0] != expected_subchars[0]){
4883 log_err("Unexpected value of sub chars\n");
4884 }
4885 ucnv_setSubstChars (cnv2,new_subchars, len, &errorCode);
4886 if(U_FAILURE(errorCode)) {
4887 log_err("Failure on set subst chars: %s\n", u_errorName(errorCode));
4888 }
4889 ucnv_getSubstChars (cnv2, get_subchars, &len, &errorCode);
4890 if(U_FAILURE(errorCode)) {
4891 log_err("Failure on get subst chars: %s\n", u_errorName(errorCode));
4892 }
4893 if (len!=1){
4894 log_err("Unexpected length of sub chars\n");
4895 }
4896 if (get_subchars[0] != new_subchars[0]){
4897 log_err("Unexpected value of sub chars\n");
4898 }
4899 ucnv_close(cnv1);
4900 ucnv_close(cnv2);
4901
4902 }
4903
4904 /* LMBCS to Unicode - offsets */
4905 {
4906 UErrorCode errorCode=U_ZERO_ERROR;
4907
4908 const char * pSource = (const char *)pszLMBCS;
4909 const char * sourceLimit = (const char *)pszLMBCS + sizeof(pszLMBCS);
4910
4911 UChar Out [sizeof(pszUnicode) + 1];
4912 UChar * pOut = Out;
4913 UChar * OutLimit = Out + UPRV_LENGTHOF(pszUnicode);
4914
4915 int32_t off [sizeof(offsets)];
4916
4917 /* last 'offset' in expected results is just the final size.
4918 (Makes other tests easier). Compensate here: */
4919
4920 off[UPRV_LENGTHOF(offsets)-1] = sizeof(pszLMBCS);
4921
4922
4923
4924 cnv=ucnv_open("lmbcs", &errorCode); /* use generic name for LMBCS-1 */
4925 if(U_FAILURE(errorCode)) {
4926 log_data_err("Unable to open a LMBCS converter: %s\n", u_errorName(errorCode));
4927 return;
4928 }
4929
4930
4931
4932 ucnv_toUnicode (cnv,
4933 &pOut,
4934 OutLimit,
4935 &pSource,
4936 sourceLimit,
4937 off,
4938 TRUE,
4939 &errorCode);
4940
4941
4942 if (memcmp(off,offsets,sizeof(offsets)))
4943 {
4944 log_err("LMBCS->Uni: Calculated offsets do not match expected results\n");
4945 }
4946 if (memcmp(Out,pszUnicode,sizeof(pszUnicode)))
4947 {
4948 log_err("LMBCS->Uni: Calculated codepoints do not match expected results\n");
4949 }
4950 ucnv_close(cnv);
4951 }
4952 {
4953 /* LMBCS to Unicode - getNextUChar */
4954 const char * sourceStart;
4955 const char *source=(const char *)pszLMBCS;
4956 const char *limit=(const char *)pszLMBCS+sizeof(pszLMBCS);
4957 const UChar32 *results= pszUnicode32;
4958 const int *off = offsets32;
4959
4960 UErrorCode errorCode=U_ZERO_ERROR;
4961 UChar32 uniChar;
4962
4963 cnv=ucnv_open("LMBCS-1", &errorCode);
4964 if(U_FAILURE(errorCode)) {
4965 log_data_err("Unable to open a LMBCS-1 converter: %s\n", u_errorName(errorCode));
4966 return;
4967 }
4968 else
4969 {
4970
4971 while(source<limit) {
4972 sourceStart=source;
4973 uniChar=ucnv_getNextUChar(cnv, &source, source + (off[1] - off[0]), &errorCode);
4974 if(U_FAILURE(errorCode)) {
4975 log_err("LMBCS-1 ucnv_getNextUChar() failed: %s\n", u_errorName(errorCode));
4976 break;
4977 } else if(source-sourceStart != off[1] - off[0] || uniChar != *results) {
4978 log_err("LMBCS-1 ucnv_getNextUChar() result %lx from %d bytes, should have been %lx from %d bytes.\n",
4979 uniChar, (source-sourceStart), *results, *off);
4980 break;
4981 }
4982 results++;
4983 off++;
4984 }
4985 }
4986 ucnv_close(cnv);
4987 }
4988 { /* test locale & optimization group operations: Unicode to LMBCS */
4989
4990 UErrorCode errorCode=U_ZERO_ERROR;
4991 UConverter *cnv16he = ucnv_open("LMBCS-16,locale=he", &errorCode);
4992 UConverter *cnv16jp = ucnv_open("LMBCS-16,locale=ja_JP", &errorCode);
4993 UConverter *cnv01us = ucnv_open("LMBCS-1,locale=us_EN", &errorCode);
4994 UChar uniString [] = {0x0192}; /* Latin Small letter f with hook */
4995 const UChar * pUniOut = uniString;
4996 UChar * pUniIn = uniString;
4997 uint8_t lmbcsString [4];
4998 const char * pLMBCSOut = (const char *)lmbcsString;
4999 char * pLMBCSIn = (char *)lmbcsString;
5000
5001 /* 0192 (hook) converts to both group 3 & group 1. input locale should differentiate */
5002 ucnv_fromUnicode (cnv16he,
5003 &pLMBCSIn, (pLMBCSIn + UPRV_LENGTHOF(lmbcsString)),
5004 &pUniOut, pUniOut + UPRV_LENGTHOF(uniString),
5005 NULL, 1, &errorCode);
5006
5007 if (lmbcsString[0] != 0x3 || lmbcsString[1] != 0x83)
5008 {
5009 log_err("LMBCS-16,locale=he gives unexpected translation\n");
5010 }
5011
5012 pLMBCSIn= (char *)lmbcsString;
5013 pUniOut = uniString;
5014 ucnv_fromUnicode (cnv01us,
5015 &pLMBCSIn, (const char *)(lmbcsString + UPRV_LENGTHOF(lmbcsString)),
5016 &pUniOut, pUniOut + UPRV_LENGTHOF(uniString),
5017 NULL, 1, &errorCode);
5018
5019 if (lmbcsString[0] != 0x9F)
5020 {
5021 log_err("LMBCS-1,locale=US gives unexpected translation\n");
5022 }
5023
5024 /* single byte char from mbcs char set */
5025 lmbcsString[0] = 0xAE; /* 1/2 width katakana letter small Yo */
5026 pLMBCSOut = (const char *)lmbcsString;
5027 pUniIn = uniString;
5028 ucnv_toUnicode (cnv16jp,
5029 &pUniIn, pUniIn + 1,
5030 &pLMBCSOut, (pLMBCSOut + 1),
5031 NULL, 1, &errorCode);
5032 if (U_FAILURE(errorCode) || pLMBCSOut != (const char *)lmbcsString+1 || pUniIn != uniString+1 || uniString[0] != 0xFF6E)
5033 {
5034 log_err("Unexpected results from LMBCS-16 single byte char\n");
5035 }
5036 /* convert to group 1: should be 3 bytes */
5037 pLMBCSIn = (char *)lmbcsString;
5038 pUniOut = uniString;
5039 ucnv_fromUnicode (cnv01us,
5040 &pLMBCSIn, (const char *)(pLMBCSIn + 3),
5041 &pUniOut, pUniOut + 1,
5042 NULL, 1, &errorCode);
5043 if (U_FAILURE(errorCode) || pLMBCSIn != (const char *)lmbcsString+3 || pUniOut != uniString+1
5044 || lmbcsString[0] != 0x10 || lmbcsString[1] != 0x10 || lmbcsString[2] != 0xAE)
5045 {
5046 log_err("Unexpected results to LMBCS-1 single byte mbcs char\n");
5047 }
5048 pLMBCSOut = (const char *)lmbcsString;
5049 pUniIn = uniString;
5050 ucnv_toUnicode (cnv01us,
5051 &pUniIn, pUniIn + 1,
5052 &pLMBCSOut, (const char *)(pLMBCSOut + 3),
5053 NULL, 1, &errorCode);
5054 if (U_FAILURE(errorCode) || pLMBCSOut != (const char *)lmbcsString+3 || pUniIn != uniString+1 || uniString[0] != 0xFF6E)
5055 {
5056 log_err("Unexpected results from LMBCS-1 single byte mbcs char\n");
5057 }
5058 pLMBCSIn = (char *)lmbcsString;
5059 pUniOut = uniString;
5060 ucnv_fromUnicode (cnv16jp,
5061 &pLMBCSIn, (const char *)(pLMBCSIn + 1),
5062 &pUniOut, pUniOut + 1,
5063 NULL, 1, &errorCode);
5064 if (U_FAILURE(errorCode) || pLMBCSIn != (const char *)lmbcsString+1 || pUniOut != uniString+1 || lmbcsString[0] != 0xAE)
5065 {
5066 log_err("Unexpected results to LMBCS-16 single byte mbcs char\n");
5067 }
5068 ucnv_close(cnv16he);
5069 ucnv_close(cnv16jp);
5070 ucnv_close(cnv01us);
5071 }
5072 {
5073 /* Small source buffer testing, LMBCS -> Unicode */
5074
5075 UErrorCode errorCode=U_ZERO_ERROR;
5076
5077 const char * pSource = (const char *)pszLMBCS;
5078 const char * sourceLimit = (const char *)pszLMBCS + sizeof(pszLMBCS);
5079 int codepointCount = 0;
5080
5081 UChar Out [sizeof(pszUnicode) + 1];
5082 UChar * pOut = Out;
5083 UChar * OutLimit = Out + UPRV_LENGTHOF(pszUnicode);
5084
5085
5086 cnv = ucnv_open(NAME_LMBCS_1, &errorCode);
5087 if(U_FAILURE(errorCode)) {
5088 log_err("Unable to open a LMBCS-1 converter: %s\n", u_errorName(errorCode));
5089 return;
5090 }
5091
5092
5093 while ((pSource < sourceLimit) && U_SUCCESS (errorCode))
5094 {
5095 ucnv_toUnicode (cnv,
5096 &pOut,
5097 OutLimit,
5098 &pSource,
5099 (pSource+1), /* claim that this is a 1- byte buffer */
5100 NULL,
5101 FALSE, /* FALSE means there might be more chars in the next buffer */
5102 &errorCode);
5103
5104 if (U_SUCCESS (errorCode))
5105 {
5106 if ((pSource - (const char *)pszLMBCS) == offsets [codepointCount+1])
5107 {
5108 /* we are on to the next code point: check value */
5109
5110 if (Out[0] != pszUnicode[codepointCount]){
5111 log_err("LMBCS->Uni result %lx should have been %lx \n",
5112 Out[0], pszUnicode[codepointCount]);
5113 }
5114
5115 pOut = Out; /* reset for accumulating next code point */
5116 codepointCount++;
5117 }
5118 }
5119 else
5120 {
5121 log_err("Unexpected Error on toUnicode: %s\n", u_errorName(errorCode));
5122 }
5123 }
5124 {
5125 /* limits & surrogate error testing */
5126 char LIn [sizeof(pszLMBCS)];
5127 const char * pLIn = LIn;
5128
5129 char LOut [sizeof(pszLMBCS)];
5130 char * pLOut = LOut;
5131
5132 UChar UOut [sizeof(pszUnicode)];
5133 UChar * pUOut = UOut;
5134
5135 UChar UIn [sizeof(pszUnicode)];
5136 const UChar * pUIn = UIn;
5137
5138 int32_t off [sizeof(offsets)];
5139 UChar32 uniChar;
5140
5141 errorCode=U_ZERO_ERROR;
5142
5143 /* negative source request should always return U_ILLEGAL_ARGUMENT_ERROR */
5144 pUIn++;
5145 ucnv_fromUnicode(cnv, &pLOut, pLOut+1, &pUIn, pUIn-1, off, FALSE, &errorCode);
5146 if (errorCode != U_ILLEGAL_ARGUMENT_ERROR)
5147 {
5148 log_err("Unexpected Error on negative source request to ucnv_fromUnicode: %s\n", u_errorName(errorCode));
5149 }
5150 pUIn--;
5151
5152 errorCode=U_ZERO_ERROR;
5153 ucnv_toUnicode(cnv, &pUOut,pUOut+1,(const char **)&pLIn,(const char *)(pLIn-1),off,FALSE, &errorCode);
5154 if (errorCode != U_ILLEGAL_ARGUMENT_ERROR)
5155 {
5156 log_err("Unexpected Error on negative source request to ucnv_toUnicode: %s\n", u_errorName(errorCode));
5157 }
5158 errorCode=U_ZERO_ERROR;
5159
5160 uniChar = ucnv_getNextUChar(cnv, (const char **)&pLIn, (const char *)(pLIn-1), &errorCode);
5161 if (errorCode != U_ILLEGAL_ARGUMENT_ERROR)
5162 {
5163 log_err("Unexpected Error on negative source request to ucnv_getNextUChar: %s\n", u_errorName(errorCode));
5164 }
5165 errorCode=U_ZERO_ERROR;
5166
5167 /* 0 byte source request - no error, no pointer movement */
5168 ucnv_toUnicode(cnv, &pUOut,pUOut+1,(const char **)&pLIn,(const char *)pLIn,off,FALSE, &errorCode);
5169 ucnv_fromUnicode(cnv, &pLOut,pLOut+1,&pUIn,pUIn,off,FALSE, &errorCode);
5170 if(U_FAILURE(errorCode)) {
5171 log_err("0 byte source request: unexpected error: %s\n", u_errorName(errorCode));
5172 }
5173 if ((pUOut != UOut) || (pUIn != UIn) || (pLOut != LOut) || (pLIn != LIn))
5174 {
5175 log_err("Unexpected pointer move in 0 byte source request \n");
5176 }
5177 /*0 byte source request - GetNextUChar : error & value == fffe or ffff */
5178 uniChar = ucnv_getNextUChar(cnv, (const char **)&pLIn, (const char *)pLIn, &errorCode);
5179 if (errorCode != U_INDEX_OUTOFBOUNDS_ERROR)
5180 {
5181 log_err("Unexpected Error on 0-byte source request to ucnv_getnextUChar: %s\n", u_errorName(errorCode));
5182 }
5183 if (((uint32_t)uniChar - 0xfffe) > 1) /* not 0xfffe<=uniChar<=0xffff */
5184 {
5185 log_err("Unexpected value on 0-byte source request to ucnv_getnextUChar \n");
5186 }
5187 errorCode = U_ZERO_ERROR;
5188
5189 /* running out of target room : U_BUFFER_OVERFLOW_ERROR */
5190
5191 pUIn = pszUnicode;
5192 ucnv_fromUnicode(cnv, &pLOut,pLOut+offsets[4],&pUIn,pUIn+UPRV_LENGTHOF(pszUnicode),off,FALSE, &errorCode);
5193 if (errorCode != U_BUFFER_OVERFLOW_ERROR || pLOut != LOut + offsets[4] || pUIn != pszUnicode+4 )
5194 {
5195 log_err("Unexpected results on out of target room to ucnv_fromUnicode\n");
5196 }
5197
5198 errorCode = U_ZERO_ERROR;
5199
5200 pLIn = (const char *)pszLMBCS;
5201 ucnv_toUnicode(cnv, &pUOut,pUOut+4,&pLIn,(pLIn+sizeof(pszLMBCS)),off,FALSE, &errorCode);
5202 if (errorCode != U_BUFFER_OVERFLOW_ERROR || pUOut != UOut + 4 || pLIn != (const char *)pszLMBCS+offsets[4])
5203 {
5204 log_err("Unexpected results on out of target room to ucnv_toUnicode\n");
5205 }
5206
5207 /* unpaired or chopped LMBCS surrogates */
5208
5209 /* OK high surrogate, Low surrogate is chopped */
5210 LIn [0] = (char)0x14;
5211 LIn [1] = (char)0xD8;
5212 LIn [2] = (char)0x01;
5213 LIn [3] = (char)0x14;
5214 LIn [4] = (char)0xDC;
5215 pLIn = LIn;
5216 errorCode = U_ZERO_ERROR;
5217 pUOut = UOut;
5218
5219 ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, NULL, NULL, NULL, &errorCode);
5220 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
5221 if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
5222 {
5223 log_err("Unexpected results on chopped low surrogate\n");
5224 }
5225
5226 /* chopped at surrogate boundary */
5227 LIn [0] = (char)0x14;
5228 LIn [1] = (char)0xD8;
5229 LIn [2] = (char)0x01;
5230 pLIn = LIn;
5231 errorCode = U_ZERO_ERROR;
5232 pUOut = UOut;
5233
5234 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+3),off,TRUE, &errorCode);
5235 if (UOut[0] != 0xD801 || U_FAILURE(errorCode) || pUOut != UOut + 1 || pLIn != LIn + 3)
5236 {
5237 log_err("Unexpected results on chopped at surrogate boundary \n");
5238 }
5239
5240 /* unpaired surrogate plus valid Unichar */
5241 LIn [0] = (char)0x14;
5242 LIn [1] = (char)0xD8;
5243 LIn [2] = (char)0x01;
5244 LIn [3] = (char)0x14;
5245 LIn [4] = (char)0xC9;
5246 LIn [5] = (char)0xD0;
5247 pLIn = LIn;
5248 errorCode = U_ZERO_ERROR;
5249 pUOut = UOut;
5250
5251 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+6),off,TRUE, &errorCode);
5252 if (UOut[0] != 0xD801 || UOut[1] != 0xC9D0 || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 6)
5253 {
5254 log_err("Unexpected results after unpaired surrogate plus valid Unichar \n");
5255 }
5256
5257 /* unpaired surrogate plus chopped Unichar */
5258 LIn [0] = (char)0x14;
5259 LIn [1] = (char)0xD8;
5260 LIn [2] = (char)0x01;
5261 LIn [3] = (char)0x14;
5262 LIn [4] = (char)0xC9;
5263
5264 pLIn = LIn;
5265 errorCode = U_ZERO_ERROR;
5266 pUOut = UOut;
5267
5268 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
5269 if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 5)
5270 {
5271 log_err("Unexpected results after unpaired surrogate plus chopped Unichar \n");
5272 }
5273
5274 /* unpaired surrogate plus valid non-Unichar */
5275 LIn [0] = (char)0x14;
5276 LIn [1] = (char)0xD8;
5277 LIn [2] = (char)0x01;
5278 LIn [3] = (char)0x0F;
5279 LIn [4] = (char)0x3B;
5280
5281 pLIn = LIn;
5282 errorCode = U_ZERO_ERROR;
5283 pUOut = UOut;
5284
5285 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+5),off,TRUE, &errorCode);
5286 if (UOut[0] != 0xD801 || UOut[1] != 0x1B || U_FAILURE(errorCode) || pUOut != UOut + 2 || pLIn != LIn + 5)
5287 {
5288 log_err("Unexpected results after unpaired surrogate plus valid non-Unichar\n");
5289 }
5290
5291 /* unpaired surrogate plus chopped non-Unichar */
5292 LIn [0] = (char)0x14;
5293 LIn [1] = (char)0xD8;
5294 LIn [2] = (char)0x01;
5295 LIn [3] = (char)0x0F;
5296
5297 pLIn = LIn;
5298 errorCode = U_ZERO_ERROR;
5299 pUOut = UOut;
5300
5301 ucnv_toUnicode(cnv, &pUOut,pUOut+UPRV_LENGTHOF(UOut),(const char **)&pLIn,(const char *)(pLIn+4),off,TRUE, &errorCode);
5302
5303 if (UOut[0] != 0xD801 || errorCode != U_TRUNCATED_CHAR_FOUND || pUOut != UOut + 1 || pLIn != LIn + 4)
5304 {
5305 log_err("Unexpected results after unpaired surrogate plus chopped non-Unichar\n");
5306 }
5307 }
5308 }
5309 ucnv_close(cnv); /* final cleanup */
5310 }
5311
5312
5313 static void TestJitterbug255()
5314 {
5315 static const uint8_t testBytes[] = { 0x95, 0xcf, 0x8a, 0xb7, 0x0d, 0x0a, 0x00 };
5316 const char *testBuffer = (const char *)testBytes;
5317 const char *testEnd = (const char *)testBytes + sizeof(testBytes);
5318 UErrorCode status = U_ZERO_ERROR;
5319 /*UChar32 result;*/
5320 UConverter *cnv = 0;
5321
5322 cnv = ucnv_open("shift-jis", &status);
5323 if (U_FAILURE(status) || cnv == 0) {
5324 log_data_err("Failed to open the converter for SJIS.\n");
5325 return;
5326 }
5327 while (testBuffer != testEnd)
5328 {
5329 /*result = */ucnv_getNextUChar (cnv, &testBuffer, testEnd , &status);
5330 if (U_FAILURE(status))
5331 {
5332 log_err("Failed to convert the next UChar for SJIS.\n");
5333 break;
5334 }
5335 }
5336 ucnv_close(cnv);
5337 }
5338
5339 static void TestEBCDICUS4XML()
5340 {
5341 UChar unicodes_x[] = {0x0000, 0x0000, 0x0000, 0x0000};
5342 static const UChar toUnicodeMaps_x[] = {0x000A, 0x000A, 0x000D, 0x0000};
5343 static const char fromUnicodeMaps_x[] = {0x25, 0x25, 0x0D, 0x00};
5344 static const char newLines_x[] = {0x25, 0x15, 0x0D, 0x00};
5345 char target_x[] = {0x00, 0x00, 0x00, 0x00};
5346 UChar *unicodes = unicodes_x;
5347 const UChar *toUnicodeMaps = toUnicodeMaps_x;
5348 char *target = target_x;
5349 const char* fromUnicodeMaps = fromUnicodeMaps_x, *newLines = newLines_x;
5350 UErrorCode status = U_ZERO_ERROR;
5351 UConverter *cnv = 0;
5352
5353 cnv = ucnv_open("ebcdic-xml-us", &status);
5354 if (U_FAILURE(status) || cnv == 0) {
5355 log_data_err("Failed to open the converter for EBCDIC-XML-US.\n");
5356 return;
5357 }
5358 ucnv_toUnicode(cnv, &unicodes, unicodes+3, (const char**)&newLines, newLines+3, NULL, TRUE, &status);
5359 if (U_FAILURE(status) || memcmp(unicodes_x, toUnicodeMaps, sizeof(UChar)*3) != 0) {
5360 log_err("To Unicode conversion failed in EBCDICUS4XML test. %s\n",
5361 u_errorName(status));
5362 printUSeqErr(unicodes_x, 3);
5363 printUSeqErr(toUnicodeMaps, 3);
5364 }
5365 status = U_ZERO_ERROR;
5366 ucnv_fromUnicode(cnv, &target, target+3, (const UChar**)&toUnicodeMaps, toUnicodeMaps+3, NULL, TRUE, &status);
5367 if (U_FAILURE(status) || memcmp(target_x, fromUnicodeMaps, sizeof(char)*3) != 0) {
5368 log_err("From Unicode conversion failed in EBCDICUS4XML test. %s\n",
5369 u_errorName(status));
5370 printSeqErr((const unsigned char*)target_x, 3);
5371 printSeqErr((const unsigned char*)fromUnicodeMaps, 3);
5372 }
5373 ucnv_close(cnv);
5374 }
5375 #endif /* #if !UCONFIG_NO_LEGACY_COLLATION */
5376
5377 #if !UCONFIG_NO_COLLATION
5378
5379 static void TestJitterbug981(){
5380 const UChar* rules;
5381 int32_t rules_length, target_cap, bytes_needed, buff_size;
5382 UErrorCode status = U_ZERO_ERROR;
5383 UConverter *utf8cnv;
5384 UCollator* myCollator;
5385 char *buff;
5386 int numNeeded=0;
5387 utf8cnv = ucnv_open ("utf8", &status);
5388 if(U_FAILURE(status)){
5389 log_err("Could not open UTF-8 converter. Error: %s\n", u_errorName(status));
5390 return;
5391 }
5392 myCollator = ucol_open("zh", &status);
5393 if(U_FAILURE(status)){
5394 log_data_err("Could not open collator for zh locale. Error: %s\n", u_errorName(status));
5395 ucnv_close(utf8cnv);
5396 return;
5397 }
5398
5399 rules = ucol_getRules(myCollator, &rules_length);
5400 if(rules_length == 0) {
5401 log_data_err("missing zh tailoring rule string\n");
5402 ucol_close(myCollator);
5403 ucnv_close(utf8cnv);
5404 return;
5405 }
5406 buff_size = rules_length * ucnv_getMaxCharSize(utf8cnv);
5407 buff = malloc(buff_size);
5408
5409 target_cap = 0;
5410 do {
5411 ucnv_reset(utf8cnv);
5412 status = U_ZERO_ERROR;
5413 if(target_cap >= buff_size) {
5414 log_err("wanted %d bytes, only %d available\n", target_cap, buff_size);
5415 break;
5416 }
5417 bytes_needed = ucnv_fromUChars(utf8cnv, buff, target_cap,
5418 rules, rules_length, &status);
5419 target_cap = (bytes_needed > target_cap) ? bytes_needed : target_cap +1;
5420 if(numNeeded!=0 && numNeeded!= bytes_needed){
5421 log_err("ucnv_fromUChars returns different values for required capacity in pre-flight and conversion modes");
5422 break;
5423 }
5424 numNeeded = bytes_needed;
5425 } while (status == U_BUFFER_OVERFLOW_ERROR);
5426 ucol_close(myCollator);
5427 ucnv_close(utf8cnv);
5428 free(buff);
5429 }
5430
5431 #endif
5432
5433 #if !UCONFIG_NO_LEGACY_CONVERSION
5434 static void TestJitterbug1293(){
5435 static const UChar src[] = {0x30DE, 0x30A4, 0x5E83, 0x544A, 0x30BF, 0x30A4, 0x30D7,0x000};
5436 char target[256];
5437 UErrorCode status = U_ZERO_ERROR;
5438 UConverter* conv=NULL;
5439 int32_t target_cap, bytes_needed, numNeeded = 0;
5440 conv = ucnv_open("shift-jis",&status);
5441 if(U_FAILURE(status)){
5442 log_data_err("Could not open Shift-Jis converter. Error: %s", u_errorName(status));
5443 return;
5444 }
5445
5446 do{
5447 target_cap =0;
5448 bytes_needed = ucnv_fromUChars(conv,target,256,src,u_strlen(src),&status);
5449 target_cap = (bytes_needed > target_cap) ? bytes_needed : target_cap +1;
5450 if(numNeeded!=0 && numNeeded!= bytes_needed){
5451 log_err("ucnv_fromUChars returns different values for required capacity in pre-flight and conversion modes");
5452 }
5453 numNeeded = bytes_needed;
5454 } while (status == U_BUFFER_OVERFLOW_ERROR);
5455 if(U_FAILURE(status)){
5456 log_err("An error occured in ucnv_fromUChars. Error: %s", u_errorName(status));
5457 return;
5458 }
5459 ucnv_close(conv);
5460 }
5461 #endif
5462
5463 static void TestJB5275_1(){
5464
5465 static const char* data = "\x3B\xB3\x0A" /* Easy characters */
5466 "\xC0\xE9\xBF\xE9\xE8\xD8\x0A" /* Gurmukhi test */
5467 /* Switch script: */
5468 "\xEF\x43\xC0\xE9\xBF\xE9\xE8\xD8\x0A" /* Bengali test */
5469 "\x3B\xB3\x0A" /* Easy characters - new line, so should default!*/
5470 "\xEF\x40\x3B\xB3\x0A";
5471 static const UChar expected[] ={
5472 0x003b, 0x0a15, 0x000a, /* Easy characters */
5473 0x0a5c, 0x0a4d, 0x0a39, 0x0a5c, 0x0a4d, 0x0a39, 0x000a, /* Gurmukhi test */
5474 0x09dd, 0x09dc, 0x09cd, 0x09b9, 0x000a, /* Switch script: to Bengali*/
5475 0x003b, 0x0a15, 0x000a, /* Easy characters - new line, so should default!*/
5476 0x003b, 0x0a15, 0x000a /* Back to Gurmukhi*/
5477 };
5478
5479 UErrorCode status = U_ZERO_ERROR;
5480 UConverter* conv = ucnv_open("iscii-gur", &status);
5481 UChar dest[100] = {'\0'};
5482 UChar* target = dest;
5483 UChar* targetLimit = dest+100;
5484 const char* source = data;
5485 const char* sourceLimit = data+strlen(data);
5486 const UChar* exp = expected;
5487
5488 if (U_FAILURE(status)) {
5489 log_data_err("Unable to open converter: iscii-gur got errorCode: %s\n", u_errorName(status));
5490 return;
5491 }
5492
5493 log_verbose("Testing switching back to default script when new line is encountered.\n");
5494 ucnv_toUnicode(conv, &target, targetLimit, &source, sourceLimit, NULL, TRUE, &status);
5495 if(U_FAILURE(status)){
5496 log_err("conversion failed: %s \n", u_errorName(status));
5497 }
5498 targetLimit = target;
5499 target = dest;
5500 printUSeq(target, targetLimit-target);
5501 while(target<targetLimit){
5502 if(*exp!=*target){
5503 log_err("did not get the expected output. \\u%04X != \\u%04X (got)\n", *exp, *target);
5504 }
5505 target++;
5506 exp++;
5507 }
5508 ucnv_close(conv);
5509 }
5510
5511 static void TestJB5275(){
5512 static const char* data =
5513 /* "\xEF\x42\xEF\x41\xA4\xD5\xE5\xB3\xEA\x0A" unsupported sequence \xEF\x41 */
5514 /* "\xEF\x42\xEF\x41\xD4\xDA\xB3\xE8\xEA\x0A" unsupported sequence \xEF\x41 */
5515 /* "\xEF\x44\xEF\x41\xC8\xE1\x8B\xDB\xB3\xE8 \xB3\xE4\xC1\xE8\x0A" unsupported sequence \xEF\x41 */
5516 "\xEF\x4B\xC0\xE9\xBF\xE9\xE8\xD8\x0A" /* Gurmukhi test */
5517 "\xEF\x4A\xC0\xD4\xBF\xD4\xE8\xD8\x0A" /* Gujarati test */
5518 "\xEF\x48\x38\xB3\x0A" /* Kannada test */
5519 "\xEF\x49\x39\xB3\x0A" /* Malayalam test */
5520 "\xEF\x4A\x3A\xB3\x0A" /* Gujarati test */
5521 "\xEF\x4B\x3B\xB3\x0A" /* Punjabi test */
5522 /* "\xEF\x4C\x3C\xB3\x0A" unsupported sequence \xEF\x41 */;
5523 static const UChar expected[] ={
5524 0x0A5C, 0x0A4D, 0x0A39, 0x0A5C, 0x0A4D, 0x0A39, 0x000A, /* Gurmukhi test */
5525 0x0AA2, 0x0AB5, 0x0AA1, 0x0AB5, 0x0ACD, 0x0AB9, 0x000A, /* Gujarati test */
5526 0x0038, 0x0C95, 0x000A, /* Kannada test */
5527 0x0039, 0x0D15, 0x000A, /* Malayalam test */
5528 0x003A, 0x0A95, 0x000A, /* Gujarati test */
5529 0x003B, 0x0A15, 0x000A, /* Punjabi test */
5530 };
5531
5532 UErrorCode status = U_ZERO_ERROR;
5533 UConverter* conv = ucnv_open("iscii", &status);
5534 UChar dest[100] = {'\0'};
5535 UChar* target = dest;
5536 UChar* targetLimit = dest+100;
5537 const char* source = data;
5538 const char* sourceLimit = data+strlen(data);
5539 const UChar* exp = expected;
5540 ucnv_toUnicode(conv, &target, targetLimit, &source, sourceLimit, NULL, TRUE, &status);
5541 if(U_FAILURE(status)){
5542 log_data_err("conversion failed: %s \n", u_errorName(status));
5543 }
5544 targetLimit = target;
5545 target = dest;
5546
5547 printUSeq(target, targetLimit-target);
5548
5549 while(target<targetLimit){
5550 if(*exp!=*target){
5551 log_err("did not get the expected output. \\u%04X != \\u%04X (got)\n", *exp, *target);
5552 }
5553 target++;
5554 exp++;
5555 }
5556 ucnv_close(conv);
5557 }
5558
5559 static void
5560 TestIsFixedWidth() {
5561 UErrorCode status = U_ZERO_ERROR;
5562 UConverter *cnv = NULL;
5563 int32_t i;
5564
5565 const char *fixedWidth[] = {
5566 "US-ASCII",
5567 "UTF32",
5568 "ibm-5478_P100-1995"
5569 };
5570
5571 const char *notFixedWidth[] = {
5572 "GB18030",
5573 "UTF8",
5574 "windows-949-2000",
5575 "UTF16"
5576 };
5577
5578 for (i = 0; i < UPRV_LENGTHOF(fixedWidth); i++) {
5579 cnv = ucnv_open(fixedWidth[i], &status);
5580 if (cnv == NULL || U_FAILURE(status)) {
5581 log_data_err("Error open converter: %s - %s \n", fixedWidth[i], u_errorName(status));
5582 continue;
5583 }
5584
5585 if (!ucnv_isFixedWidth(cnv, &status)) {
5586 log_err("%s is a fixedWidth converter but returned FALSE.\n", fixedWidth[i]);
5587 }
5588 ucnv_close(cnv);
5589 }
5590
5591 for (i = 0; i < UPRV_LENGTHOF(notFixedWidth); i++) {
5592 cnv = ucnv_open(notFixedWidth[i], &status);
5593 if (cnv == NULL || U_FAILURE(status)) {
5594 log_data_err("Error open converter: %s - %s \n", notFixedWidth[i], u_errorName(status));
5595 continue;
5596 }
5597
5598 if (ucnv_isFixedWidth(cnv, &status)) {
5599 log_err("%s is NOT a fixedWidth converter but returned TRUE.\n", notFixedWidth[i]);
5600 }
5601 ucnv_close(cnv);
5602 }
5603 }
mirror of ICU