]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/cintltst/nccbtst.c
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-64252.0.1.tar.gz
[apple/icu.git] / icuSources / test / cintltst / nccbtst.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 NCCBTST.C
11 *
12 * Modification History:
13 * Name Description
14 * Madhu Katragadda 7/21/1999 Testing error callback routines
15 ********************************************************************************
16 */
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <ctype.h>
21 #include "cmemory.h"
22 #include "cstring.h"
23 #include "unicode/uloc.h"
24 #include "unicode/ucnv.h"
25 #include "unicode/ucnv_err.h"
26 #include "cintltst.h"
27 #include "unicode/utypes.h"
28 #include "unicode/ustring.h"
29 #include "nccbtst.h"
30 #include "unicode/ucnv_cb.h"
31 #include "unicode/utf16.h"
32
33 #define NEW_MAX_BUFFER 999
34
35 #define nct_min(x,y) ((x<y) ? x : y)
36
37 static int32_t gInBufferSize = 0;
38 static int32_t gOutBufferSize = 0;
39 static char gNuConvTestName[1024];
40
41 static void printSeq(const uint8_t* a, int len)
42 {
43 int i=0;
44 log_verbose("\n{");
45 while (i<len)
46 log_verbose("0x%02X, ", a[i++]);
47 log_verbose("}\n");
48 }
49
50 static void printUSeq(const UChar* a, int len)
51 {
52 int i=0;
53 log_verbose("{");
54 while (i<len)
55 log_verbose(" 0x%04x, ", a[i++]);
56 log_verbose("}\n");
57 }
58
59 static void printSeqErr(const uint8_t* a, int len)
60 {
61 int i=0;
62 fprintf(stderr, "{");
63 while (i<len)
64 fprintf(stderr, " 0x%02x, ", a[i++]);
65 fprintf(stderr, "}\n");
66 }
67
68 static void printUSeqErr(const UChar* a, int len)
69 {
70 int i=0;
71 fprintf(stderr, "{");
72 while (i<len)
73 fprintf(stderr, "0x%04x, ", a[i++]);
74 fprintf(stderr,"}\n");
75 }
76
77 static void setNuConvTestName(const char *codepage, const char *direction)
78 {
79 sprintf(gNuConvTestName, "[testing %s %s Unicode, InputBufSiz=%d, OutputBufSiz=%d]",
80 codepage,
81 direction,
82 (int)gInBufferSize,
83 (int)gOutBufferSize);
84 }
85
86
87 static void TestCallBackFailure(void);
88
89 void addTestConvertErrorCallBack(TestNode** root);
90
91 void addTestConvertErrorCallBack(TestNode** root)
92 {
93 addTest(root, &TestSkipCallBack, "tsconv/nccbtst/TestSkipCallBack");
94 addTest(root, &TestStopCallBack, "tsconv/nccbtst/TestStopCallBack");
95 addTest(root, &TestSubCallBack, "tsconv/nccbtst/TestSubCallBack");
96 addTest(root, &TestSubWithValueCallBack, "tsconv/nccbtst/TestSubWithValueCallBack");
97
98 #if !UCONFIG_NO_LEGACY_CONVERSION
99 addTest(root, &TestLegalAndOtherCallBack, "tsconv/nccbtst/TestLegalAndOtherCallBack");
100 addTest(root, &TestSingleByteCallBack, "tsconv/nccbtst/TestSingleByteCallBack");
101 #endif
102
103 addTest(root, &TestCallBackFailure, "tsconv/nccbtst/TestCallBackFailure");
104 }
105
106 static void TestSkipCallBack()
107 {
108 TestSkip(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
109 TestSkip(1,NEW_MAX_BUFFER);
110 TestSkip(1,1);
111 TestSkip(NEW_MAX_BUFFER, 1);
112 }
113
114 static void TestStopCallBack()
115 {
116 TestStop(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
117 TestStop(1,NEW_MAX_BUFFER);
118 TestStop(1,1);
119 TestStop(NEW_MAX_BUFFER, 1);
120 }
121
122 static void TestSubCallBack()
123 {
124 TestSub(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
125 TestSub(1,NEW_MAX_BUFFER);
126 TestSub(1,1);
127 TestSub(NEW_MAX_BUFFER, 1);
128
129 #if !UCONFIG_NO_LEGACY_CONVERSION
130 TestEBCDIC_STATEFUL_Sub(1, 1);
131 TestEBCDIC_STATEFUL_Sub(1, NEW_MAX_BUFFER);
132 TestEBCDIC_STATEFUL_Sub(NEW_MAX_BUFFER, 1);
133 TestEBCDIC_STATEFUL_Sub(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
134 #endif
135 }
136
137 static void TestSubWithValueCallBack()
138 {
139 TestSubWithValue(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
140 TestSubWithValue(1,NEW_MAX_BUFFER);
141 TestSubWithValue(1,1);
142 TestSubWithValue(NEW_MAX_BUFFER, 1);
143 }
144
145 #if !UCONFIG_NO_LEGACY_CONVERSION
146 static void TestLegalAndOtherCallBack()
147 {
148 TestLegalAndOthers(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
149 TestLegalAndOthers(1,NEW_MAX_BUFFER);
150 TestLegalAndOthers(1,1);
151 TestLegalAndOthers(NEW_MAX_BUFFER, 1);
152 }
153
154 static void TestSingleByteCallBack()
155 {
156 TestSingleByte(NEW_MAX_BUFFER, NEW_MAX_BUFFER);
157 TestSingleByte(1,NEW_MAX_BUFFER);
158 TestSingleByte(1,1);
159 TestSingleByte(NEW_MAX_BUFFER, 1);
160 }
161 #endif
162
163 static void TestSkip(int32_t inputsize, int32_t outputsize)
164 {
165 static const uint8_t expskipIBM_949[]= {
166 0x00, 0xb0, 0xa1, 0xb0, 0xa2, 0xc8, 0xd3 };
167
168 static const uint8_t expskipIBM_943[] = {
169 0x9f, 0xaf, 0x9f, 0xb1, 0x89, 0x59 };
170
171 static const uint8_t expskipIBM_930[] = {
172 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0x46, 0x6b, 0x0f };
173
174 gInBufferSize = inputsize;
175 gOutBufferSize = outputsize;
176
177 /*From Unicode*/
178 log_verbose("Testing fromUnicode with UCNV_FROM_U_CALLBACK_SKIP \n");
179
180 #if !UCONFIG_NO_LEGACY_CONVERSION
181 {
182 static const UChar sampleText[] = { 0x0000, 0xAC00, 0xAC01, 0xEF67, 0xD700 };
183 static const UChar sampleText2[] = { 0x6D63, 0x6D64, 0x6D65, 0x6D66 };
184
185 static const int32_t toIBM949Offsskip [] = { 0, 1, 1, 2, 2, 4, 4 };
186 static const int32_t toIBM943Offsskip [] = { 0, 0, 1, 1, 3, 3 };
187
188 if(!testConvertFromUnicode(sampleText, UPRV_LENGTHOF(sampleText),
189 expskipIBM_949, UPRV_LENGTHOF(expskipIBM_949), "ibm-949",
190 UCNV_FROM_U_CALLBACK_SKIP, toIBM949Offsskip, NULL, 0 ))
191 log_err("u-> ibm-949 with skip did not match.\n");
192 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
193 expskipIBM_943, UPRV_LENGTHOF(expskipIBM_943), "ibm-943",
194 UCNV_FROM_U_CALLBACK_SKIP, toIBM943Offsskip, NULL, 0 ))
195 log_err("u-> ibm-943 with skip did not match.\n");
196 }
197
198 {
199 static const UChar fromU[] = { 0x61, 0xff5e, 0x62, 0x6d63, 0xff5e, 0x6d64, 0x63, 0xff5e, 0x6d66 };
200 static const uint8_t fromUBytes[] = { 0x62, 0x63, 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0x0f, 0x64, 0x0e, 0x46, 0x6b, 0x0f };
201 static const int32_t fromUOffsets[] = { 0, 2, 3, 3, 3, 5, 5, 6, 6, 8, 8, 8, 8 };
202
203 /* test ibm-930 (EBCDIC_STATEFUL) with fallbacks that are not taken to check correct state transitions */
204 if(!testConvertFromUnicode(fromU, UPRV_LENGTHOF(fromU),
205 fromUBytes, UPRV_LENGTHOF(fromUBytes),
206 "ibm-930",
207 UCNV_FROM_U_CALLBACK_SKIP, fromUOffsets,
208 NULL, 0)
209 ) {
210 log_err("u->ibm-930 with skip with untaken fallbacks did not match.\n");
211 }
212 }
213 #endif
214
215 {
216 static const UChar usasciiFromU[] = { 0x61, 0x80, 0x4e00, 0x31, 0xd800, 0xdfff, 0x39 };
217 static const uint8_t usasciiFromUBytes[] = { 0x61, 0x31, 0x39 };
218 static const int32_t usasciiFromUOffsets[] = { 0, 3, 6 };
219
220 static const UChar latin1FromU[] = { 0x61, 0xa0, 0x4e00, 0x31, 0xd800, 0xdfff, 0x39 };
221 static const uint8_t latin1FromUBytes[] = { 0x61, 0xa0, 0x31, 0x39 };
222 static const int32_t latin1FromUOffsets[] = { 0, 1, 3, 6 };
223
224 /* US-ASCII */
225 if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
226 usasciiFromUBytes, UPRV_LENGTHOF(usasciiFromUBytes),
227 "US-ASCII",
228 UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
229 NULL, 0)
230 ) {
231 log_err("u->US-ASCII with skip did not match.\n");
232 }
233
234 #if !UCONFIG_NO_LEGACY_CONVERSION
235 /* SBCS NLTC codepage 367 for US-ASCII */
236 if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
237 usasciiFromUBytes, UPRV_LENGTHOF(usasciiFromUBytes),
238 "ibm-367",
239 UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
240 NULL, 0)
241 ) {
242 log_err("u->ibm-367 with skip did not match.\n");
243 }
244 #endif
245
246 /* ISO-Latin-1 */
247 if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
248 latin1FromUBytes, UPRV_LENGTHOF(latin1FromUBytes),
249 "LATIN_1",
250 UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
251 NULL, 0)
252 ) {
253 log_err("u->LATIN_1 with skip did not match.\n");
254 }
255
256 #if !UCONFIG_NO_LEGACY_CONVERSION
257 /* windows-1252 */
258 if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
259 latin1FromUBytes, UPRV_LENGTHOF(latin1FromUBytes),
260 "windows-1252",
261 UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
262 NULL, 0)
263 ) {
264 log_err("u->windows-1252 with skip did not match.\n");
265 }
266 }
267
268 {
269 static const UChar inputTest[] = { 0x0061, 0xd801, 0xdc01, 0xd801, 0x0061 };
270 static const uint8_t toIBM943[]= { 0x61, 0x61 };
271 static const int32_t offset[]= {0, 4};
272
273 /* EUC_JP*/
274 static const UChar euc_jp_inputText[]={ 0x0061, 0x4edd, 0x5bec, 0xd801, 0xdc01, 0xd801, 0x0061, 0x00a2 };
275 static const uint8_t to_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
276 0x61, 0x8e, 0xe0,
277 };
278 static const int32_t fromEUC_JPOffs [] ={ 0, 1, 1, 2, 2, 2, 6, 7, 7};
279
280 /*EUC_TW*/
281 static const UChar euc_tw_inputText[]={ 0x0061, 0x2295, 0x5BF2, 0xd801, 0xdc01, 0xd801, 0x0061, 0x8706, 0x8a, };
282 static const uint8_t to_euc_tw[]={
283 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
284 0x61, 0xe6, 0xca, 0x8a,
285 };
286 static const int32_t from_euc_twOffs [] ={ 0, 1, 1, 2, 2, 2, 2, 6, 7, 7, 8,};
287
288 /*ISO-2022-JP*/
289 static const UChar iso_2022_jp_inputText[]={0x0041, 0x00E9/*unassigned*/,0x0042, };
290 static const uint8_t to_iso_2022_jp[]={
291 0x41,
292 0x42,
293
294 };
295 static const int32_t from_iso_2022_jpOffs [] ={0,2};
296
297 /*ISO-2022-JP*/
298 UChar const iso_2022_jp_inputText2[]={0x0041, 0x00E9/*unassigned*/,0x43,0xd800/*illegal*/,0x0042, };
299 static const uint8_t to_iso_2022_jp2[]={
300 0x41,
301 0x43,
302
303 };
304 static const int32_t from_iso_2022_jpOffs2 [] ={0,2};
305
306 /*ISO-2022-cn*/
307 static const UChar iso_2022_cn_inputText[]={ 0x0041, 0x3712/*unassigned*/, 0x0042, };
308 static const uint8_t to_iso_2022_cn[]={
309 0x41, 0x42
310 };
311 static const int32_t from_iso_2022_cnOffs [] ={
312 0, 2
313 };
314
315 /*ISO-2022-CN*/
316 static const UChar iso_2022_cn_inputText1[]={0x0041, 0x3712/*unassigned*/,0x43,0xd800/*illegal*/,0x0042, };
317 static const uint8_t to_iso_2022_cn1[]={
318 0x41, 0x43
319
320 };
321 static const int32_t from_iso_2022_cnOffs1 [] ={ 0, 2 };
322
323 /*ISO-2022-kr*/
324 static const UChar iso_2022_kr_inputText[]={ 0x0041, 0x03A0,0x3712/*unassigned*/,0x03A0, 0x0042, };
325 static const uint8_t to_iso_2022_kr[]={
326 0x1b, 0x24, 0x29, 0x43,
327 0x41,
328 0x0e, 0x25, 0x50,
329 0x25, 0x50,
330 0x0f, 0x42,
331 };
332 static const int32_t from_iso_2022_krOffs [] ={
333 -1,-1,-1,-1,
334 0,
335 1,1,1,
336 3,3,
337 4,4
338 };
339
340 /*ISO-2022-kr*/
341 static const UChar iso_2022_kr_inputText1[]={ 0x0041, 0x03A0,0x3712/*unassigned*/,0x03A0,0xd801/*illegal*/, 0x0042, };
342 static const uint8_t to_iso_2022_kr1[]={
343 0x1b, 0x24, 0x29, 0x43,
344 0x41,
345 0x0e, 0x25, 0x50,
346 0x25, 0x50,
347
348 };
349 static const int32_t from_iso_2022_krOffs1 [] ={
350 -1,-1,-1,-1,
351 0,
352 1,1,1,
353 3,3,
354
355 };
356 /* HZ encoding */
357 static const UChar hz_inputText[]={ 0x0041, 0x03A0,0x0662/*unassigned*/,0x03A0, 0x0042, };
358
359 static const uint8_t to_hz[]={
360 0x7e, 0x7d, 0x41,
361 0x7e, 0x7b, 0x26, 0x30,
362 0x26, 0x30,
363 0x7e, 0x7d, 0x42,
364
365 };
366 static const int32_t from_hzOffs [] ={
367 0,0,0,
368 1,1,1,1,
369 3,3,
370 4,4,4,4
371 };
372
373 static const UChar hz_inputText1[]={ 0x0041, 0x03A0,0x0662/*unassigned*/,0x03A0,0xd801/*illegal*/, 0x0042, };
374
375 static const uint8_t to_hz1[]={
376 0x7e, 0x7d, 0x41,
377 0x7e, 0x7b, 0x26, 0x30,
378 0x26, 0x30,
379
380
381 };
382 static const int32_t from_hzOffs1 [] ={
383 0,0,0,
384 1,1,1,1,
385 3,3,
386
387 };
388
389 #endif
390
391 static const UChar SCSU_inputText[]={ 0x0041, 0xd801/*illegal*/, 0x0042, };
392
393 static const uint8_t to_SCSU[]={
394 0x41,
395 0x42
396
397
398 };
399 static const int32_t from_SCSUOffs [] ={
400 0,
401 2,
402
403 };
404
405 #if !UCONFIG_NO_LEGACY_CONVERSION
406 /* ISCII */
407 static const UChar iscii_inputText[]={ 0x0041, 0x3712/*unassigned*/, 0x0042, };
408 static const uint8_t to_iscii[]={
409 0x41,
410 0x42,
411 };
412 static const int32_t from_isciiOffs [] ={
413 0,2,
414
415 };
416 /*ISCII*/
417 static const UChar iscii_inputText1[]={0x0044, 0x3712/*unassigned*/,0x43,0xd800/*illegal*/,0x0042, };
418 static const uint8_t to_iscii1[]={
419 0x44,
420 0x43,
421
422 };
423 static const int32_t from_isciiOffs1 [] ={0,2};
424
425 if(!testConvertFromUnicode(inputTest, UPRV_LENGTHOF(inputTest),
426 toIBM943, UPRV_LENGTHOF(toIBM943), "ibm-943",
427 UCNV_FROM_U_CALLBACK_SKIP, offset, NULL, 0 ))
428 log_err("u-> ibm-943 with skip did not match.\n");
429
430 if(!testConvertFromUnicode(euc_jp_inputText, UPRV_LENGTHOF(euc_jp_inputText),
431 to_euc_jp, UPRV_LENGTHOF(to_euc_jp), "IBM-eucJP",
432 UCNV_FROM_U_CALLBACK_SKIP, fromEUC_JPOffs, NULL, 0 ))
433 log_err("u-> euc-jp with skip did not match.\n");
434
435 if(!testConvertFromUnicode(euc_tw_inputText, UPRV_LENGTHOF(euc_tw_inputText),
436 to_euc_tw, UPRV_LENGTHOF(to_euc_tw), "euc-tw",
437 UCNV_FROM_U_CALLBACK_SKIP, from_euc_twOffs, NULL, 0 ))
438 log_err("u-> euc-tw with skip did not match.\n");
439
440 /*iso_2022_jp*/
441 if(!testConvertFromUnicode(iso_2022_jp_inputText, UPRV_LENGTHOF(iso_2022_jp_inputText),
442 to_iso_2022_jp, UPRV_LENGTHOF(to_iso_2022_jp), "iso-2022-jp",
443 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_jpOffs, NULL, 0 ))
444 log_err("u-> iso-2022-jp with skip did not match.\n");
445
446 /* with context */
447 if(!testConvertFromUnicodeWithContext(iso_2022_jp_inputText2, UPRV_LENGTHOF(iso_2022_jp_inputText2),
448 to_iso_2022_jp2, UPRV_LENGTHOF(to_iso_2022_jp2), "iso-2022-jp",
449 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_jpOffs2, NULL, 0,UCNV_SKIP_STOP_ON_ILLEGAL,U_ILLEGAL_CHAR_FOUND ))
450 log_err("u-> iso-2022-jp with skip & UCNV_SKIP_STOP_ON_ILLEGAL did not match.\n");
451
452 /*iso_2022_cn*/
453 if(!testConvertFromUnicode(iso_2022_cn_inputText, UPRV_LENGTHOF(iso_2022_cn_inputText),
454 to_iso_2022_cn, UPRV_LENGTHOF(to_iso_2022_cn), "iso-2022-cn",
455 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_cnOffs, NULL, 0 ))
456 log_err("u-> iso-2022-cn with skip did not match.\n");
457 /*with context*/
458 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText1, UPRV_LENGTHOF(iso_2022_cn_inputText1),
459 to_iso_2022_cn1, UPRV_LENGTHOF(to_iso_2022_cn1), "iso-2022-cn",
460 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_cnOffs1, NULL, 0,UCNV_SKIP_STOP_ON_ILLEGAL,U_ILLEGAL_CHAR_FOUND ))
461 log_err("u-> iso-2022-cn with skip & UCNV_SKIP_STOP_ON_ILLEGAL did not match.\n");
462
463 /*iso_2022_kr*/
464 if(!testConvertFromUnicode(iso_2022_kr_inputText, UPRV_LENGTHOF(iso_2022_kr_inputText),
465 to_iso_2022_kr, UPRV_LENGTHOF(to_iso_2022_kr), "iso-2022-kr",
466 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_krOffs, NULL, 0 ))
467 log_err("u-> iso-2022-kr with skip did not match.\n");
468 /*with context*/
469 if(!testConvertFromUnicodeWithContext(iso_2022_kr_inputText1, UPRV_LENGTHOF(iso_2022_kr_inputText1),
470 to_iso_2022_kr1, UPRV_LENGTHOF(to_iso_2022_kr1), "iso-2022-kr",
471 UCNV_FROM_U_CALLBACK_SKIP, from_iso_2022_krOffs1, NULL, 0,UCNV_SKIP_STOP_ON_ILLEGAL,U_ILLEGAL_CHAR_FOUND ))
472 log_err("u-> iso-2022-kr with skip & UCNV_SKIP_STOP_ON_ILLEGAL did not match.\n");
473
474 /*hz*/
475 if(!testConvertFromUnicode(hz_inputText, UPRV_LENGTHOF(hz_inputText),
476 to_hz, UPRV_LENGTHOF(to_hz), "HZ",
477 UCNV_FROM_U_CALLBACK_SKIP, from_hzOffs, NULL, 0 ))
478 log_err("u-> HZ with skip did not match.\n");
479 /*with context*/
480 if(!testConvertFromUnicodeWithContext(hz_inputText1, UPRV_LENGTHOF(hz_inputText1),
481 to_hz1, UPRV_LENGTHOF(to_hz1), "hz",
482 UCNV_FROM_U_CALLBACK_SKIP, from_hzOffs1, NULL, 0,UCNV_SKIP_STOP_ON_ILLEGAL,U_ILLEGAL_CHAR_FOUND ))
483 log_err("u-> hz with skip & UCNV_SKIP_STOP_ON_ILLEGAL did not match.\n");
484 #endif
485
486 /*SCSU*/
487 if(!testConvertFromUnicode(SCSU_inputText, UPRV_LENGTHOF(SCSU_inputText),
488 to_SCSU, UPRV_LENGTHOF(to_SCSU), "SCSU",
489 UCNV_FROM_U_CALLBACK_SKIP, from_SCSUOffs, NULL, 0 ))
490 log_err("u-> SCSU with skip did not match.\n");
491
492 #if !UCONFIG_NO_LEGACY_CONVERSION
493 /*ISCII*/
494 if(!testConvertFromUnicode(iscii_inputText, UPRV_LENGTHOF(iscii_inputText),
495 to_iscii, UPRV_LENGTHOF(to_iscii), "ISCII,version=0",
496 UCNV_FROM_U_CALLBACK_SKIP, from_isciiOffs, NULL, 0 ))
497 log_err("u-> iscii with skip did not match.\n");
498 /*with context*/
499 if(!testConvertFromUnicodeWithContext(iscii_inputText1, UPRV_LENGTHOF(iscii_inputText1),
500 to_iscii1, UPRV_LENGTHOF(to_iscii1), "ISCII,version=0",
501 UCNV_FROM_U_CALLBACK_SKIP, from_isciiOffs1, NULL, 0,UCNV_SKIP_STOP_ON_ILLEGAL,U_ILLEGAL_CHAR_FOUND ))
502 log_err("u-> iscii with skip & UCNV_SKIP_STOP_ON_ILLEGAL did not match.\n");
503 #endif
504 }
505
506 log_verbose("Testing fromUnicode for BOCU-1 with UCNV_TO_U_CALLBACK_SKIP\n");
507 {
508 static const uint8_t sampleText[]={ /* from cintltst/bocu1tst.c/TestBOCU1 text 1 */
509 0xFB, 0xEE, 0x28, /* from source offset 0 */
510 0x24, 0x1E, 0x52,
511 0xB2,
512 0x20,
513 0xB3,
514 0xB1,
515 0x0D,
516 0x0A,
517
518 0x20, /* from 8 */
519 0x00,
520 0xD0, 0x6C,
521 0xB6,
522 0xD8, 0xA5,
523 0x20,
524 0x68,
525 0x59,
526
527 0xF9, 0x28, /* from 16 */
528 0x6D,
529 0x20,
530 0x73,
531 0xE0, 0x2D,
532 0xDE, 0x43,
533 0xD0, 0x33,
534 0x20,
535
536 0xFA, 0x83, /* from 24 */
537 0x25, 0x01,
538 0xFB, 0x16, 0x87,
539 0x4B, 0x16,
540 0x20,
541 0xE6, 0xBD,
542 0xEB, 0x5B,
543 0x4B, 0xCC,
544
545 0xF9, 0xA2, /* from 32 */
546 0xFC, 0x10, 0x3E,
547 0xFE, 0x16, 0x3A, 0x8C,
548 0x20,
549 0xFC, 0x03, 0xAC,
550
551 0x01, /* from 41 */
552 0xDE, 0x83,
553 0x20,
554 0x09
555 };
556 static const UChar expected[]={
557 0xFEFF, 0x0061, 0x0062, 0x0020, /* 0 */
558 0x0063, 0x0061, 0x000D, 0x000A,
559
560 0x0020, 0x0000, 0x00DF, 0x00E6, /* 8 */
561 0x0930, 0x0020, 0x0918, 0x0909,
562
563 0x3086, 0x304D, 0x0020, 0x3053, /* 16 */
564 0x4000, 0x4E00, 0x7777, 0x0020,
565
566 0x9FA5, 0x4E00, 0xAC00, 0xBCDE, /* 24 */
567 0x0020, 0xD7A3, 0xDC00, 0xD800,
568
569 0xD800, 0xDC00, 0xD845, 0xDDDD, /* 32 */
570 0xDBBB, 0xDDEE, 0x0020, 0xDBFF,
571
572 0xDFFF, 0x0001, 0x0E40, 0x0020, /* 40 */
573 0x0009
574 };
575 static const int32_t offsets[]={
576 0, 0, 0, 1, 1, 1, 2, 3, 4, 5, 6, 7,
577 8, 9, 10, 10, 11, 12, 12, 13, 14, 15,
578 16, 16, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23,
579 24, 24, 25, 25, 26, 26, 26, 27, 27, 28, 29, 29, 30, 30, 31, 31,
580 32, 32, 34, 34, 34, 36, 36, 36, 36, 38, 39, 39, 39,
581 41, 42, 42, 43, 44
582 };
583
584 /* BOCU-1 fromUnicode never calls callbacks, so this only tests single-byte and offsets behavior */
585 if(!testConvertFromUnicode(expected, UPRV_LENGTHOF(expected),
586 sampleText, UPRV_LENGTHOF(sampleText),
587 "BOCU-1",
588 UCNV_FROM_U_CALLBACK_SKIP, offsets, NULL, 0)
589 ) {
590 log_err("u->BOCU-1 with skip did not match.\n");
591 }
592 }
593
594 log_verbose("Testing fromUnicode for CESU-8 with UCNV_TO_U_CALLBACK_SKIP\n");
595 {
596 const uint8_t sampleText[]={
597 0x61, /* 'a' */
598 0xc4, 0xb5, /* U+0135 */
599 0xed, 0x80, 0xa0, /* Hangul U+d020 */
600 0xed, 0xa0, 0x81, 0xed, 0xb0, 0x81, /* surrogate pair for U+10401 */
601 0xee, 0x80, 0x80, /* PUA U+e000 */
602 0xed, 0xb0, 0x81, /* unpaired trail surrogate U+dc01 */
603 0x62, /* 'b' */
604 0xed, 0xa0, 0x81, /* unpaired lead surrogate U+d801 */
605 0xd0, 0x80 /* U+0400 */
606 };
607 UChar expected[]={
608 0x0061,
609 0x0135,
610 0xd020,
611 0xd801, 0xdc01,
612 0xe000,
613 0xdc01,
614 0x0062,
615 0xd801,
616 0x0400
617 };
618 int32_t offsets[]={
619 0,
620 1, 1,
621 2, 2, 2,
622 3, 3, 3, 4, 4, 4,
623 5, 5, 5,
624 6, 6, 6,
625 7,
626 8, 8, 8,
627 9, 9
628 };
629
630 /* CESU-8 fromUnicode never calls callbacks, so this only tests conversion and offsets behavior */
631
632 /* without offsets */
633 if(!testConvertFromUnicode(expected, UPRV_LENGTHOF(expected),
634 sampleText, UPRV_LENGTHOF(sampleText),
635 "CESU-8",
636 UCNV_FROM_U_CALLBACK_SKIP, NULL, NULL, 0)
637 ) {
638 log_err("u->CESU-8 with skip did not match.\n");
639 }
640
641 /* with offsets */
642 if(!testConvertFromUnicode(expected, UPRV_LENGTHOF(expected),
643 sampleText, UPRV_LENGTHOF(sampleText),
644 "CESU-8",
645 UCNV_FROM_U_CALLBACK_SKIP, offsets, NULL, 0)
646 ) {
647 log_err("u->CESU-8 with skip did not match.\n");
648 }
649 }
650
651 /*to Unicode*/
652 log_verbose("Testing toUnicode with UCNV_TO_U_CALLBACK_SKIP \n");
653
654 #if !UCONFIG_NO_LEGACY_CONVERSION
655 {
656
657 static const UChar IBM_949skiptoUnicode[]= {0x0000, 0xAC00, 0xAC01, 0xD700 };
658 static const UChar IBM_943skiptoUnicode[]= { 0x6D63, 0x6D64, 0x6D66 };
659 static const UChar IBM_930skiptoUnicode[]= { 0x6D63, 0x6D64, 0x6D66 };
660
661 static const int32_t fromIBM949Offs [] = { 0, 1, 3, 5};
662 static const int32_t fromIBM943Offs [] = { 0, 2, 4};
663 static const int32_t fromIBM930Offs [] = { 1, 3, 5};
664
665 if(!testConvertToUnicode(expskipIBM_949, UPRV_LENGTHOF(expskipIBM_949),
666 IBM_949skiptoUnicode, UPRV_LENGTHOF(IBM_949skiptoUnicode),"ibm-949",
667 UCNV_TO_U_CALLBACK_SKIP, fromIBM949Offs, NULL, 0 ))
668 log_err("ibm-949->u with skip did not match.\n");
669 if(!testConvertToUnicode(expskipIBM_943, UPRV_LENGTHOF(expskipIBM_943),
670 IBM_943skiptoUnicode, UPRV_LENGTHOF(IBM_943skiptoUnicode),"ibm-943",
671 UCNV_TO_U_CALLBACK_SKIP, fromIBM943Offs, NULL, 0 ))
672 log_err("ibm-943->u with skip did not match.\n");
673
674
675 if(!testConvertToUnicode(expskipIBM_930, UPRV_LENGTHOF(expskipIBM_930),
676 IBM_930skiptoUnicode, UPRV_LENGTHOF(IBM_930skiptoUnicode),"ibm-930",
677 UCNV_TO_U_CALLBACK_SKIP, fromIBM930Offs, NULL, 0 ))
678 log_err("ibm-930->u with skip did not match.\n");
679
680
681 if(!testConvertToUnicodeWithContext(expskipIBM_930, UPRV_LENGTHOF(expskipIBM_930),
682 IBM_930skiptoUnicode, UPRV_LENGTHOF(IBM_930skiptoUnicode),"ibm-930",
683 UCNV_TO_U_CALLBACK_SKIP, fromIBM930Offs, NULL, 0,"i",U_ILLEGAL_CHAR_FOUND ))
684 log_err("ibm-930->u with skip did not match.\n");
685 }
686 #endif
687
688 {
689 static const uint8_t usasciiToUBytes[] = { 0x61, 0x80, 0x31 };
690 static const UChar usasciiToU[] = { 0x61, 0x31 };
691 static const int32_t usasciiToUOffsets[] = { 0, 2 };
692
693 static const uint8_t latin1ToUBytes[] = { 0x61, 0xa0, 0x31 };
694 static const UChar latin1ToU[] = { 0x61, 0xa0, 0x31 };
695 static const int32_t latin1ToUOffsets[] = { 0, 1, 2 };
696
697 /* US-ASCII */
698 if(!testConvertToUnicode(usasciiToUBytes, UPRV_LENGTHOF(usasciiToUBytes),
699 usasciiToU, UPRV_LENGTHOF(usasciiToU),
700 "US-ASCII",
701 UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
702 NULL, 0)
703 ) {
704 log_err("US-ASCII->u with skip did not match.\n");
705 }
706
707 #if !UCONFIG_NO_LEGACY_CONVERSION
708 /* SBCS NLTC codepage 367 for US-ASCII */
709 if(!testConvertToUnicode(usasciiToUBytes, UPRV_LENGTHOF(usasciiToUBytes),
710 usasciiToU, UPRV_LENGTHOF(usasciiToU),
711 "ibm-367",
712 UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
713 NULL, 0)
714 ) {
715 log_err("ibm-367->u with skip did not match.\n");
716 }
717 #endif
718
719 /* ISO-Latin-1 */
720 if(!testConvertToUnicode(latin1ToUBytes, UPRV_LENGTHOF(latin1ToUBytes),
721 latin1ToU, UPRV_LENGTHOF(latin1ToU),
722 "LATIN_1",
723 UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
724 NULL, 0)
725 ) {
726 log_err("LATIN_1->u with skip did not match.\n");
727 }
728
729 #if !UCONFIG_NO_LEGACY_CONVERSION
730 /* windows-1252 */
731 if(!testConvertToUnicode(latin1ToUBytes, UPRV_LENGTHOF(latin1ToUBytes),
732 latin1ToU, UPRV_LENGTHOF(latin1ToU),
733 "windows-1252",
734 UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
735 NULL, 0)
736 ) {
737 log_err("windows-1252->u with skip did not match.\n");
738 }
739 #endif
740 }
741
742 #if !UCONFIG_NO_LEGACY_CONVERSION
743 {
744 static const uint8_t sampleTxtEBCIDIC_STATEFUL [] ={
745 0x0e, 0x5d, 0x5f , 0x41, 0x79, 0x41, 0x44
746 };
747 static const UChar EBCIDIC_STATEFUL_toUnicode[] ={ 0x6d63, 0x03b4
748 };
749 static const int32_t from_EBCIDIC_STATEFULOffsets []={ 1, 5};
750
751
752 /* euc-jp*/
753 static const uint8_t sampleTxt_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
754 0x8f, 0xda, 0xa1, /*unassigned*/
755 0x8e, 0xe0,
756 };
757 static const UChar euc_jptoUnicode[]={ 0x0061, 0x4edd, 0x5bec, 0x00a2};
758 static const int32_t from_euc_jpOffs [] ={ 0, 1, 3, 9};
759
760 /*EUC_TW*/
761 static const uint8_t sampleTxt_euc_tw[]={ 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
762 0x8e, 0xaa, 0xbb, 0xcc,/*unassigned*/
763 0xe6, 0xca, 0x8a,
764 };
765 static const UChar euc_twtoUnicode[]={ 0x0061, 0x2295, 0x5BF2, 0x8706, 0x8a, };
766 static const int32_t from_euc_twOffs [] ={ 0, 1, 3, 11, 13};
767 /*iso-2022-jp*/
768 static const uint8_t sampleTxt_iso_2022_jp[]={
769 0x41,
770 0x1b, 0x24, 0x42, 0x3a, 0x1a, /*unassigned*/
771 0x1b, 0x28, 0x42, 0x42,
772
773 };
774 static const UChar iso_2022_jptoUnicode[]={ 0x41,0x42 };
775 static const int32_t from_iso_2022_jpOffs [] ={ 0,9 };
776
777 /*iso-2022-cn*/
778 static const uint8_t sampleTxt_iso_2022_cn[]={
779 0x0f, 0x41, 0x44,
780 0x1B, 0x24, 0x29, 0x47,
781 0x0E, 0x40, 0x6f, /*unassigned*/
782 0x0f, 0x42,
783
784 };
785
786 static const UChar iso_2022_cntoUnicode[]={ 0x41, 0x44,0x42 };
787 static const int32_t from_iso_2022_cnOffs [] ={ 1, 2, 11 };
788
789 /*iso-2022-kr*/
790 static const uint8_t sampleTxt_iso_2022_kr[]={
791 0x1b, 0x24, 0x29, 0x43,
792 0x41,
793 0x0E, 0x7f, 0x1E,
794 0x0e, 0x25, 0x50,
795 0x0f, 0x51,
796 0x42, 0x43,
797
798 };
799 static const UChar iso_2022_krtoUnicode[]={ 0x41,0x03A0,0x51, 0x42,0x43};
800 static const int32_t from_iso_2022_krOffs [] ={ 4, 9, 12, 13 , 14 };
801
802 /*hz*/
803 static const uint8_t sampleTxt_hz[]={
804 0x41,
805 0x7e, 0x7b, 0x26, 0x30,
806 0x7f, 0x1E, /*unassigned*/
807 0x26, 0x30,
808 0x7e, 0x7d, 0x42,
809 0x7e, 0x7b, 0x7f, 0x1E,/*unassigned*/
810 0x7e, 0x7d, 0x42,
811 };
812 static const UChar hztoUnicode[]={
813 0x41,
814 0x03a0,
815 0x03A0,
816 0x42,
817 0x42,};
818
819 static const int32_t from_hzOffs [] ={0,3,7,11,18, };
820
821 /*ISCII*/
822 static const uint8_t sampleTxt_iscii[]={
823 0x41,
824 0xa1,
825 0xEB, /*unassigned*/
826 0x26,
827 0x30,
828 0xa2,
829 0xEC, /*unassigned*/
830 0x42,
831 };
832 static const UChar isciitoUnicode[]={
833 0x41,
834 0x0901,
835 0x26,
836 0x30,
837 0x0902,
838 0x42,
839 };
840
841 static const int32_t from_isciiOffs [] ={0,1,3,4,5,7 };
842
843 /*LMBCS*/
844 static const uint8_t sampleTxtLMBCS[]={ 0x12, 0xc9, 0x50,
845 0x12, 0x92, 0xa0, /*unassigned*/
846 0x12, 0x92, 0xA1,
847 };
848 static const UChar LMBCSToUnicode[]={ 0x4e2e, 0xe5c4};
849 static const int32_t fromLMBCS[] = {0, 6};
850
851 if(!testConvertToUnicode(sampleTxtEBCIDIC_STATEFUL, UPRV_LENGTHOF(sampleTxtEBCIDIC_STATEFUL),
852 EBCIDIC_STATEFUL_toUnicode, UPRV_LENGTHOF(EBCIDIC_STATEFUL_toUnicode),"ibm-930",
853 UCNV_TO_U_CALLBACK_SKIP, from_EBCIDIC_STATEFULOffsets, NULL, 0 ))
854 log_err("EBCIDIC_STATEFUL->u with skip did not match.\n");
855
856 if(!testConvertToUnicodeWithContext(sampleTxtEBCIDIC_STATEFUL, UPRV_LENGTHOF(sampleTxtEBCIDIC_STATEFUL),
857 EBCIDIC_STATEFUL_toUnicode, UPRV_LENGTHOF(EBCIDIC_STATEFUL_toUnicode),"ibm-930",
858 UCNV_TO_U_CALLBACK_SKIP, from_EBCIDIC_STATEFULOffsets, NULL, 0,"i",U_ILLEGAL_CHAR_FOUND ))
859 log_err("EBCIDIC_STATEFUL->u with skip did not match.\n");
860
861 if(!testConvertToUnicode(sampleTxt_euc_jp, UPRV_LENGTHOF(sampleTxt_euc_jp),
862 euc_jptoUnicode, UPRV_LENGTHOF(euc_jptoUnicode),"IBM-eucJP",
863 UCNV_TO_U_CALLBACK_SKIP, from_euc_jpOffs , NULL, 0))
864 log_err("euc-jp->u with skip did not match.\n");
865
866
867
868 if(!testConvertToUnicode(sampleTxt_euc_tw, UPRV_LENGTHOF(sampleTxt_euc_tw),
869 euc_twtoUnicode, UPRV_LENGTHOF(euc_twtoUnicode),"euc-tw",
870 UCNV_TO_U_CALLBACK_SKIP, from_euc_twOffs , NULL, 0))
871 log_err("euc-tw->u with skip did not match.\n");
872
873
874 if(!testConvertToUnicode(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
875 iso_2022_jptoUnicode, UPRV_LENGTHOF(iso_2022_jptoUnicode),"iso-2022-jp",
876 UCNV_TO_U_CALLBACK_SKIP, from_iso_2022_jpOffs , NULL, 0))
877 log_err("iso-2022-jp->u with skip did not match.\n");
878
879 if(!testConvertToUnicode(sampleTxt_iso_2022_cn, UPRV_LENGTHOF(sampleTxt_iso_2022_cn),
880 iso_2022_cntoUnicode, UPRV_LENGTHOF(iso_2022_cntoUnicode),"iso-2022-cn",
881 UCNV_TO_U_CALLBACK_SKIP, from_iso_2022_cnOffs , NULL, 0))
882 log_err("iso-2022-cn->u with skip did not match.\n");
883
884 if(!testConvertToUnicode(sampleTxt_iso_2022_kr, UPRV_LENGTHOF(sampleTxt_iso_2022_kr),
885 iso_2022_krtoUnicode, UPRV_LENGTHOF(iso_2022_krtoUnicode),"iso-2022-kr",
886 UCNV_TO_U_CALLBACK_SKIP, from_iso_2022_krOffs , NULL, 0))
887 log_err("iso-2022-kr->u with skip did not match.\n");
888
889 if(!testConvertToUnicode(sampleTxt_hz, UPRV_LENGTHOF(sampleTxt_hz),
890 hztoUnicode, UPRV_LENGTHOF(hztoUnicode),"HZ",
891 UCNV_TO_U_CALLBACK_SKIP, from_hzOffs , NULL, 0))
892 log_err("HZ->u with skip did not match.\n");
893
894 if(!testConvertToUnicode(sampleTxt_iscii, UPRV_LENGTHOF(sampleTxt_iscii),
895 isciitoUnicode, UPRV_LENGTHOF(isciitoUnicode),"ISCII,version=0",
896 UCNV_TO_U_CALLBACK_SKIP, from_isciiOffs , NULL, 0))
897 log_err("iscii->u with skip did not match.\n");
898
899 if(!testConvertToUnicode(sampleTxtLMBCS, UPRV_LENGTHOF(sampleTxtLMBCS),
900 LMBCSToUnicode, UPRV_LENGTHOF(LMBCSToUnicode),"LMBCS-1",
901 UCNV_TO_U_CALLBACK_SKIP, fromLMBCS , NULL, 0))
902 log_err("LMBCS->u with skip did not match.\n");
903
904 }
905 #endif
906
907 log_verbose("Testing to Unicode for UTF-8 with UCNV_TO_U_CALLBACK_SKIP \n");
908 {
909 const uint8_t sampleText1[] = { 0x31, 0xe4, 0xba, 0x8c,
910 0xe0, 0x80, 0x61,};
911 UChar expected1[] = { 0x0031, 0x4e8c, 0x0061};
912 int32_t offsets1[] = { 0x0000, 0x0001, 0x0006};
913
914 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
915 expected1, UPRV_LENGTHOF(expected1),"utf8",
916 UCNV_TO_U_CALLBACK_SKIP, offsets1, NULL, 0 ))
917 log_err("utf8->u with skip did not match.\n");;
918 }
919
920 log_verbose("Testing toUnicode for SCSU with UCNV_TO_U_CALLBACK_SKIP \n");
921 {
922 const uint8_t sampleText1[] = { 0xba, 0x8c,0xF8, 0x61,0x0c, 0x0c,};
923 UChar expected1[] = { 0x00ba, 0x008c, 0x00f8, 0x0061,0xfffe,0xfffe};
924 int32_t offsets1[] = { 0x0000, 0x0001,0x0002,0x0003,4,5};
925
926 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
927 expected1, UPRV_LENGTHOF(expected1),"SCSU",
928 UCNV_TO_U_CALLBACK_SKIP, offsets1, NULL, 0 ))
929 log_err("scsu->u with skip did not match.\n");
930 }
931
932 log_verbose("Testing toUnicode for BOCU-1 with UCNV_TO_U_CALLBACK_SKIP\n");
933 {
934 const uint8_t sampleText[]={ /* modified from cintltst/bocu1tst.c/TestBOCU1 text 1 */
935 0xFB, 0xEE, 0x28, /* single-code point sequence at offset 0 */
936 0x24, 0x1E, 0x52, /* 3 */
937 0xB2, /* 6 */
938 0x20, /* 7 */
939 0x40, 0x07, /* 8 - wrong trail byte */
940 0xB3, /* 10 */
941 0xB1, /* 11 */
942 0xD0, 0x20, /* 12 - wrong trail byte */
943 0x0D, /* 14 */
944 0x0A, /* 15 */
945 0x20, /* 16 */
946 0x00, /* 17 */
947 0xD0, 0x6C, /* 18 */
948 0xB6, /* 20 */
949 0xD8, 0xA5, /* 21 */
950 0x20, /* 23 */
951 0x68, /* 24 */
952 0x59, /* 25 */
953 0xF9, 0x28, /* 26 */
954 0x6D, /* 28 */
955 0x20, /* 29 */
956 0x73, /* 30 */
957 0xE0, 0x2D, /* 31 */
958 0xDE, 0x43, /* 33 */
959 0xD0, 0x33, /* 35 */
960 0x20, /* 37 */
961 0xFA, 0x83, /* 38 */
962 0x25, 0x01, /* 40 */
963 0xFB, 0x16, 0x87, /* 42 */
964 0x4B, 0x16, /* 45 */
965 0x20, /* 47 */
966 0xE6, 0xBD, /* 48 */
967 0xEB, 0x5B, /* 50 */
968 0x4B, 0xCC, /* 52 */
969 0xF9, 0xA2, /* 54 */
970 0xFC, 0x10, 0x3E, /* 56 */
971 0xFE, 0x16, 0x3A, 0x8C, /* 59 */
972 0x20, /* 63 */
973 0xFC, 0x03, 0xAC, /* 64 */
974 0xFF, /* 67 - FF just resets the state without encoding anything */
975 0x01, /* 68 */
976 0xDE, 0x83, /* 69 */
977 0x20, /* 71 */
978 0x09 /* 72 */
979 };
980 UChar expected[]={
981 0xFEFF, 0x0061, 0x0062, 0x0020,
982 0x0063, 0x0061, 0x000D, 0x000A,
983 0x0020, 0x0000, 0x00DF, 0x00E6,
984 0x0930, 0x0020, 0x0918, 0x0909,
985 0x3086, 0x304D, 0x0020, 0x3053,
986 0x4000, 0x4E00, 0x7777, 0x0020,
987 0x9FA5, 0x4E00, 0xAC00, 0xBCDE,
988 0x0020, 0xD7A3, 0xDC00, 0xD800,
989 0xD800, 0xDC00, 0xD845, 0xDDDD,
990 0xDBBB, 0xDDEE, 0x0020, 0xDBFF,
991 0xDFFF, 0x0001, 0x0E40, 0x0020,
992 0x0009
993 };
994 int32_t offsets[]={
995 0, 3, 6, 7, /* skip 8, */
996 10, 11, /* skip 12, */
997 14, 15, 16, 17, 18,
998 20, 21, 23, 24, 25, 26, 28, 29,
999 30, 31, 33, 35, 37, 38,
1000 40, 42, 45, 47, 48,
1001 50, 52, 54, /* trail */ 54, 56, /* trail */ 56, 59, /* trail */ 59,
1002 63, 64, /* trail */ 64, /* reset only 67, */
1003 68, 69,
1004 71, 72
1005 };
1006
1007 if(!testConvertToUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1008 expected, UPRV_LENGTHOF(expected), "BOCU-1",
1009 UCNV_TO_U_CALLBACK_SKIP, offsets, NULL, 0)
1010 ) {
1011 log_err("BOCU-1->u with skip did not match.\n");
1012 }
1013 }
1014
1015 log_verbose("Testing toUnicode for CESU-8 with UCNV_TO_U_CALLBACK_SKIP\n");
1016 {
1017 const uint8_t sampleText[]={
1018 0x61, /* 0 'a' */
1019 0xc0, 0x80, /* 1 non-shortest form */
1020 0xc4, 0xb5, /* 3 U+0135 */
1021 0xed, 0x80, 0xa0, /* 5 Hangul U+d020 */
1022 0xed, 0xa0, 0x81, 0xed, 0xb0, 0x81, /* 8 surrogate pair for U+10401 */
1023 0xee, 0x80, 0x80, /* 14 PUA U+e000 */
1024 0xed, 0xb0, 0x81, /* 17 unpaired trail surrogate U+dc01 */
1025 0xf0, 0x90, 0x80, 0x80, /* 20 illegal 4-byte form for U+10000 */
1026 0x62, /* 24 'b' */
1027 0xed, 0xa0, 0x81, /* 25 unpaired lead surrogate U+d801 */
1028 0xed, 0xa0, /* 28 incomplete sequence */
1029 0xd0, 0x80 /* 30 U+0400 */
1030 };
1031 UChar expected[]={
1032 0x0061,
1033 /* skip */
1034 0x0135,
1035 0xd020,
1036 0xd801, 0xdc01,
1037 0xe000,
1038 0xdc01,
1039 /* skip */
1040 0x0062,
1041 0xd801,
1042 0x0400
1043 };
1044 int32_t offsets[]={
1045 0,
1046 /* skip 1, */
1047 3,
1048 5,
1049 8, 11,
1050 14,
1051 17,
1052 /* skip 20, 20, */
1053 24,
1054 25,
1055 /* skip 28 */
1056 30
1057 };
1058
1059 /* without offsets */
1060 if(!testConvertToUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1061 expected, UPRV_LENGTHOF(expected), "CESU-8",
1062 UCNV_TO_U_CALLBACK_SKIP, NULL, NULL, 0)
1063 ) {
1064 log_err("CESU-8->u with skip did not match.\n");
1065 }
1066
1067 /* with offsets */
1068 if(!testConvertToUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1069 expected, UPRV_LENGTHOF(expected), "CESU-8",
1070 UCNV_TO_U_CALLBACK_SKIP, offsets, NULL, 0)
1071 ) {
1072 log_err("CESU-8->u with skip did not match.\n");
1073 }
1074 }
1075 }
1076
1077 static void TestStop(int32_t inputsize, int32_t outputsize)
1078 {
1079 static const UChar sampleText[] = { 0x0000, 0xAC00, 0xAC01, 0xEF67, 0xD700 };
1080 static const UChar sampleText2[] = { 0x6D63, 0x6D64, 0x6D65, 0x6D66 };
1081
1082 static const uint8_t expstopIBM_949[]= {
1083 0x00, 0xb0, 0xa1, 0xb0, 0xa2};
1084
1085 static const uint8_t expstopIBM_943[] = {
1086 0x9f, 0xaf, 0x9f, 0xb1};
1087
1088 static const uint8_t expstopIBM_930[] = {
1089 0x0e, 0x5d, 0x5f, 0x5d, 0x63};
1090
1091 static const UChar IBM_949stoptoUnicode[]= {0x0000, 0xAC00, 0xAC01};
1092 static const UChar IBM_943stoptoUnicode[]= { 0x6D63, 0x6D64};
1093 static const UChar IBM_930stoptoUnicode[]= { 0x6D63, 0x6D64};
1094
1095
1096 static const int32_t toIBM949Offsstop [] = { 0, 1, 1, 2, 2};
1097 static const int32_t toIBM943Offsstop [] = { 0, 0, 1, 1};
1098 static const int32_t toIBM930Offsstop [] = { 0, 0, 0, 1, 1};
1099
1100 static const int32_t fromIBM949Offs [] = { 0, 1, 3};
1101 static const int32_t fromIBM943Offs [] = { 0, 2};
1102 static const int32_t fromIBM930Offs [] = { 1, 3};
1103
1104 gInBufferSize = inputsize;
1105 gOutBufferSize = outputsize;
1106
1107 /*From Unicode*/
1108
1109 #if !UCONFIG_NO_LEGACY_CONVERSION
1110 if(!testConvertFromUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1111 expstopIBM_949, UPRV_LENGTHOF(expstopIBM_949), "ibm-949",
1112 UCNV_FROM_U_CALLBACK_STOP, toIBM949Offsstop, NULL, 0 ))
1113 log_err("u-> ibm-949 with stop did not match.\n");
1114 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1115 expstopIBM_943, UPRV_LENGTHOF(expstopIBM_943), "ibm-943",
1116 UCNV_FROM_U_CALLBACK_STOP, toIBM943Offsstop , NULL, 0))
1117 log_err("u-> ibm-943 with stop did not match.\n");
1118 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1119 expstopIBM_930, UPRV_LENGTHOF(expstopIBM_930), "ibm-930",
1120 UCNV_FROM_U_CALLBACK_STOP, toIBM930Offsstop, NULL, 0 ))
1121 log_err("u-> ibm-930 with stop did not match.\n");
1122
1123 log_verbose("Testing fromUnicode with UCNV_FROM_U_CALLBACK_STOP \n");
1124 {
1125 static const UChar inputTest[] = { 0x0061, 0xd801, 0xdc01, 0xd801, 0x0061 };
1126 static const uint8_t toIBM943[]= { 0x61,};
1127 static const int32_t offset[]= {0,} ;
1128
1129 /*EUC_JP*/
1130 static const UChar euc_jp_inputText[]={ 0x0061, 0x4edd, 0x5bec, 0xd801, 0xdc01, 0xd801, 0x0061, 0x00a2 };
1131 static const uint8_t to_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,};
1132 static const int32_t fromEUC_JPOffs [] ={ 0, 1, 1, 2, 2, 2,};
1133
1134 /*EUC_TW*/
1135 static const UChar euc_tw_inputText[]={ 0x0061, 0x2295, 0x5BF2, 0xd801, 0xdc01, 0xd801, 0x0061, 0x8706, 0x8a, };
1136 static const uint8_t to_euc_tw[]={
1137 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,};
1138 static const int32_t from_euc_twOffs [] ={ 0, 1, 1, 2, 2, 2, 2,};
1139
1140 /*ISO-2022-JP*/
1141 static const UChar iso_2022_jp_inputText[]={0x0041, 0x00E9, 0x0042, };
1142 static const uint8_t to_iso_2022_jp[]={
1143 0x41,
1144
1145 };
1146 static const int32_t from_iso_2022_jpOffs [] ={0,};
1147
1148 /*ISO-2022-cn*/
1149 static const UChar iso_2022_cn_inputText[]={ 0x0041, 0x3712, 0x0042, };
1150 static const uint8_t to_iso_2022_cn[]={
1151 0x41,
1152
1153 };
1154 static const int32_t from_iso_2022_cnOffs [] ={
1155 0,0,
1156 2,2,
1157 };
1158
1159 /*ISO-2022-kr*/
1160 static const UChar iso_2022_kr_inputText[]={ 0x0041, 0x03A0,0x3712/*unassigned*/,0x03A0, 0x0042, };
1161 static const uint8_t to_iso_2022_kr[]={
1162 0x1b, 0x24, 0x29, 0x43,
1163 0x41,
1164 0x0e, 0x25, 0x50,
1165 };
1166 static const int32_t from_iso_2022_krOffs [] ={
1167 -1,-1,-1,-1,
1168 0,
1169 1,1,1,
1170 };
1171
1172 /* HZ encoding */
1173 static const UChar hz_inputText[]={ 0x0041, 0x03A0,0x0662/*unassigned*/,0x03A0, 0x0042, };
1174
1175 static const uint8_t to_hz[]={
1176 0x7e, 0x7d, 0x41,
1177 0x7e, 0x7b, 0x26, 0x30,
1178
1179 };
1180 static const int32_t from_hzOffs [] ={
1181 0, 0,0,
1182 1,1,1,1,
1183 };
1184
1185 /*ISCII*/
1186 static const UChar iscii_inputText[]={ 0x0041, 0x3712, 0x0042, };
1187 static const uint8_t to_iscii[]={
1188 0x41,
1189 };
1190 static const int32_t from_isciiOffs [] ={
1191 0,
1192 };
1193
1194 if(!testConvertFromUnicode(inputTest, UPRV_LENGTHOF(inputTest),
1195 toIBM943, UPRV_LENGTHOF(toIBM943), "ibm-943",
1196 UCNV_FROM_U_CALLBACK_STOP, offset, NULL, 0 ))
1197 log_err("u-> ibm-943 with stop did not match.\n");
1198
1199 if(!testConvertFromUnicode(euc_jp_inputText, UPRV_LENGTHOF(euc_jp_inputText),
1200 to_euc_jp, UPRV_LENGTHOF(to_euc_jp), "IBM-eucJP",
1201 UCNV_FROM_U_CALLBACK_STOP, fromEUC_JPOffs, NULL, 0 ))
1202 log_err("u-> euc-jp with stop did not match.\n");
1203
1204 if(!testConvertFromUnicode(euc_tw_inputText, UPRV_LENGTHOF(euc_tw_inputText),
1205 to_euc_tw, UPRV_LENGTHOF(to_euc_tw), "euc-tw",
1206 UCNV_FROM_U_CALLBACK_STOP, from_euc_twOffs, NULL, 0 ))
1207 log_err("u-> euc-tw with stop did not match.\n");
1208
1209 if(!testConvertFromUnicode(iso_2022_jp_inputText, UPRV_LENGTHOF(iso_2022_jp_inputText),
1210 to_iso_2022_jp, UPRV_LENGTHOF(to_iso_2022_jp), "iso-2022-jp",
1211 UCNV_FROM_U_CALLBACK_STOP, from_iso_2022_jpOffs, NULL, 0 ))
1212 log_err("u-> iso-2022-jp with stop did not match.\n");
1213
1214 if(!testConvertFromUnicode(iso_2022_jp_inputText, UPRV_LENGTHOF(iso_2022_jp_inputText),
1215 to_iso_2022_jp, UPRV_LENGTHOF(to_iso_2022_jp), "iso-2022-jp",
1216 UCNV_FROM_U_CALLBACK_STOP, from_iso_2022_jpOffs, NULL, 0 ))
1217 log_err("u-> iso-2022-jp with stop did not match.\n");
1218
1219 if(!testConvertFromUnicode(iso_2022_cn_inputText, UPRV_LENGTHOF(iso_2022_cn_inputText),
1220 to_iso_2022_cn, UPRV_LENGTHOF(to_iso_2022_cn), "iso-2022-cn",
1221 UCNV_FROM_U_CALLBACK_STOP, from_iso_2022_cnOffs, NULL, 0 ))
1222 log_err("u-> iso-2022-cn with stop did not match.\n");
1223
1224 if(!testConvertFromUnicode(iso_2022_kr_inputText, UPRV_LENGTHOF(iso_2022_kr_inputText),
1225 to_iso_2022_kr, UPRV_LENGTHOF(to_iso_2022_kr), "iso-2022-kr",
1226 UCNV_FROM_U_CALLBACK_STOP, from_iso_2022_krOffs, NULL, 0 ))
1227 log_err("u-> iso-2022-kr with stop did not match.\n");
1228
1229 if(!testConvertFromUnicode(hz_inputText, UPRV_LENGTHOF(hz_inputText),
1230 to_hz, UPRV_LENGTHOF(to_hz), "HZ",
1231 UCNV_FROM_U_CALLBACK_STOP, from_hzOffs, NULL, 0 ))
1232 log_err("u-> HZ with stop did not match.\n");\
1233
1234 if(!testConvertFromUnicode(iscii_inputText, UPRV_LENGTHOF(iscii_inputText),
1235 to_iscii, UPRV_LENGTHOF(to_iscii), "ISCII,version=0",
1236 UCNV_FROM_U_CALLBACK_STOP, from_isciiOffs, NULL, 0 ))
1237 log_err("u-> iscii with stop did not match.\n");
1238
1239
1240 }
1241 #endif
1242
1243 log_verbose("Testing fromUnicode for SCSU with UCNV_FROM_U_CALLBACK_STOP \n");
1244 {
1245 static const UChar SCSU_inputText[]={ 0x0041, 0xd801/*illegal*/, 0x0042, };
1246
1247 static const uint8_t to_SCSU[]={
1248 0x41,
1249
1250 };
1251 int32_t from_SCSUOffs [] ={
1252 0,
1253
1254 };
1255 if(!testConvertFromUnicode(SCSU_inputText, UPRV_LENGTHOF(SCSU_inputText),
1256 to_SCSU, UPRV_LENGTHOF(to_SCSU), "SCSU",
1257 UCNV_FROM_U_CALLBACK_STOP, from_SCSUOffs, NULL, 0 ))
1258 log_err("u-> SCSU with skip did not match.\n");
1259
1260 }
1261
1262 /*to Unicode*/
1263
1264 #if !UCONFIG_NO_LEGACY_CONVERSION
1265 if(!testConvertToUnicode(expstopIBM_949, UPRV_LENGTHOF(expstopIBM_949),
1266 IBM_949stoptoUnicode, UPRV_LENGTHOF(IBM_949stoptoUnicode),"ibm-949",
1267 UCNV_TO_U_CALLBACK_STOP, fromIBM949Offs, NULL, 0 ))
1268 log_err("ibm-949->u with stop did not match.\n");
1269 if(!testConvertToUnicode(expstopIBM_943, UPRV_LENGTHOF(expstopIBM_943),
1270 IBM_943stoptoUnicode, UPRV_LENGTHOF(IBM_943stoptoUnicode),"ibm-943",
1271 UCNV_TO_U_CALLBACK_STOP, fromIBM943Offs, NULL, 0 ))
1272 log_err("ibm-943->u with stop did not match.\n");
1273 if(!testConvertToUnicode(expstopIBM_930, UPRV_LENGTHOF(expstopIBM_930),
1274 IBM_930stoptoUnicode, UPRV_LENGTHOF(IBM_930stoptoUnicode),"ibm-930",
1275 UCNV_TO_U_CALLBACK_STOP, fromIBM930Offs, NULL, 0 ))
1276 log_err("ibm-930->u with stop did not match.\n");
1277
1278 log_verbose("Testing toUnicode with UCNV_TO_U_CALLBACK_STOP \n");
1279 {
1280
1281 static const uint8_t sampleTxtEBCIDIC_STATEFUL [] ={
1282 0x0e, 0x5d, 0x5f , 0x41, 0x79, 0x41, 0x44
1283 };
1284 static const UChar EBCIDIC_STATEFUL_toUnicode[] ={ 0x6d63 };
1285 static const int32_t from_EBCIDIC_STATEFULOffsets []={ 1};
1286
1287
1288 /*EUC-JP*/
1289 static const uint8_t sampleTxt_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
1290 0x8f, 0xda, 0xa1, /*unassigned*/
1291 0x8e, 0xe0,
1292 };
1293 static const UChar euc_jptoUnicode[]={ 0x0061, 0x4edd, 0x5bec};
1294 static const int32_t from_euc_jpOffs [] ={ 0, 1, 3};
1295
1296 /*EUC_TW*/
1297 static const uint8_t sampleTxt_euc_tw[]={ 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
1298 0x8e, 0xaa, 0xbb, 0xcc,/*unassigned*/
1299 0xe6, 0xca, 0x8a,
1300 };
1301 UChar euc_twtoUnicode[]={ 0x0061, 0x2295, 0x5BF2};
1302 int32_t from_euc_twOffs [] ={ 0, 1, 3};
1303
1304
1305
1306 if(!testConvertToUnicode(sampleTxtEBCIDIC_STATEFUL, UPRV_LENGTHOF(sampleTxtEBCIDIC_STATEFUL),
1307 EBCIDIC_STATEFUL_toUnicode, UPRV_LENGTHOF(EBCIDIC_STATEFUL_toUnicode),"ibm-930",
1308 UCNV_TO_U_CALLBACK_STOP, from_EBCIDIC_STATEFULOffsets, NULL, 0 ))
1309 log_err("EBCIDIC_STATEFUL->u with stop did not match.\n");
1310
1311 if(!testConvertToUnicode(sampleTxt_euc_jp, UPRV_LENGTHOF(sampleTxt_euc_jp),
1312 euc_jptoUnicode, UPRV_LENGTHOF(euc_jptoUnicode),"IBM-eucJP",
1313 UCNV_TO_U_CALLBACK_STOP, from_euc_jpOffs , NULL, 0))
1314 log_err("euc-jp->u with stop did not match.\n");
1315
1316 if(!testConvertToUnicode(sampleTxt_euc_tw, UPRV_LENGTHOF(sampleTxt_euc_tw),
1317 euc_twtoUnicode, UPRV_LENGTHOF(euc_twtoUnicode),"euc-tw",
1318 UCNV_TO_U_CALLBACK_STOP, from_euc_twOffs, NULL, 0 ))
1319 log_err("euc-tw->u with stop did not match.\n");
1320 }
1321 #endif
1322
1323 log_verbose("Testing toUnicode for UTF-8 with UCNV_TO_U_CALLBACK_STOP \n");
1324 {
1325 static const uint8_t sampleText1[] = { 0x31, 0xe4, 0xba, 0x8c,
1326 0xe0, 0x80, 0x61,};
1327 static const UChar expected1[] = { 0x0031, 0x4e8c,};
1328 static const int32_t offsets1[] = { 0x0000, 0x0001};
1329
1330 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
1331 expected1, UPRV_LENGTHOF(expected1),"utf8",
1332 UCNV_TO_U_CALLBACK_STOP, offsets1, NULL, 0 ))
1333 log_err("utf8->u with stop did not match.\n");;
1334 }
1335 log_verbose("Testing toUnicode for SCSU with UCNV_TO_U_CALLBACK_STOP \n");
1336 {
1337 static const uint8_t sampleText1[] = { 0xba, 0x8c,0xF8, 0x61,0x0c, 0x0c,0x04};
1338 static const UChar expected1[] = { 0x00ba, 0x008c, 0x00f8, 0x0061};
1339 static const int32_t offsets1[] = { 0x0000, 0x0001,0x0002,0x0003};
1340
1341 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
1342 expected1, UPRV_LENGTHOF(expected1),"SCSU",
1343 UCNV_TO_U_CALLBACK_STOP, offsets1, NULL, 0 ))
1344 log_err("scsu->u with stop did not match.\n");;
1345 }
1346
1347 }
1348
1349 static void TestSub(int32_t inputsize, int32_t outputsize)
1350 {
1351 static const UChar sampleText[] = { 0x0000, 0xAC00, 0xAC01, 0xEF67, 0xD700 };
1352 static const UChar sampleText2[]= { 0x6D63, 0x6D64, 0x6D65, 0x6D66 };
1353
1354 static const uint8_t expsubIBM_949[] =
1355 { 0x00, 0xb0, 0xa1, 0xb0, 0xa2, 0xaf, 0xfe, 0xc8, 0xd3 };
1356
1357 static const uint8_t expsubIBM_943[] = {
1358 0x9f, 0xaf, 0x9f, 0xb1, 0xfc, 0xfc, 0x89, 0x59 };
1359
1360 static const uint8_t expsubIBM_930[] = {
1361 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0xfe, 0xfe, 0x46, 0x6b, 0x0f };
1362
1363 static const UChar IBM_949subtoUnicode[]= {0x0000, 0xAC00, 0xAC01, 0xfffd, 0xD700 };
1364 static const UChar IBM_943subtoUnicode[]= {0x6D63, 0x6D64, 0xfffd, 0x6D66 };
1365 static const UChar IBM_930subtoUnicode[]= {0x6D63, 0x6D64, 0xfffd, 0x6D66 };
1366
1367 static const int32_t toIBM949Offssub [] ={ 0, 1, 1, 2, 2, 3, 3, 4, 4 };
1368 static const int32_t toIBM943Offssub [] ={ 0, 0, 1, 1, 2, 2, 3, 3 };
1369 static const int32_t toIBM930Offssub [] ={ 0, 0, 0, 1, 1, 2, 2, 3, 3, 3 };
1370
1371 static const int32_t fromIBM949Offs [] = { 0, 1, 3, 5, 7 };
1372 static const int32_t fromIBM943Offs [] = { 0, 2, 4, 6 };
1373 static const int32_t fromIBM930Offs [] = { 1, 3, 5, 7 };
1374
1375 gInBufferSize = inputsize;
1376 gOutBufferSize = outputsize;
1377
1378 /*from unicode*/
1379
1380 #if !UCONFIG_NO_LEGACY_CONVERSION
1381 if(!testConvertFromUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1382 expsubIBM_949, UPRV_LENGTHOF(expsubIBM_949), "ibm-949",
1383 UCNV_FROM_U_CALLBACK_SUBSTITUTE, toIBM949Offssub, NULL, 0 ))
1384 log_err("u-> ibm-949 with subst did not match.\n");
1385 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1386 expsubIBM_943, UPRV_LENGTHOF(expsubIBM_943), "ibm-943",
1387 UCNV_FROM_U_CALLBACK_SUBSTITUTE, toIBM943Offssub , NULL, 0))
1388 log_err("u-> ibm-943 with subst did not match.\n");
1389 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1390 expsubIBM_930, UPRV_LENGTHOF(expsubIBM_930), "ibm-930",
1391 UCNV_FROM_U_CALLBACK_SUBSTITUTE, toIBM930Offssub, NULL, 0 ))
1392 log_err("u-> ibm-930 with subst did not match.\n");
1393
1394 log_verbose("Testing fromUnicode with UCNV_FROM_U_CALLBACK_SUBSTITUTE \n");
1395 {
1396 static const UChar inputTest[] = { 0x0061, 0xd801, 0xdc01, 0xd801, 0x0061 };
1397 static const uint8_t toIBM943[]= { 0x61, 0xfc, 0xfc, 0xfc, 0xfc, 0x61 };
1398 static const int32_t offset[]= {0, 1, 1, 3, 3, 4};
1399
1400
1401 /* EUC_JP*/
1402 static const UChar euc_jp_inputText[]={ 0x0061, 0x4edd, 0x5bec, 0xd801, 0xdc01, 0xd801, 0x0061, 0x00a2 };
1403 static const uint8_t to_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
1404 0xf4, 0xfe, 0xf4, 0xfe,
1405 0x61, 0x8e, 0xe0,
1406 };
1407 static const int32_t fromEUC_JPOffs [] ={ 0, 1, 1, 2, 2, 2, 3, 3, 5, 5, 6, 7, 7};
1408
1409 /*EUC_TW*/
1410 static const UChar euc_tw_inputText[]={ 0x0061, 0x2295, 0x5BF2, 0xd801, 0xdc01, 0xd801, 0x0061, 0x8706, 0x8a, };
1411 static const uint8_t to_euc_tw[]={
1412 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
1413 0xfd, 0xfe, 0xfd, 0xfe,
1414 0x61, 0xe6, 0xca, 0x8a,
1415 };
1416
1417 static const int32_t from_euc_twOffs [] ={ 0, 1, 1, 2, 2, 2, 2, 3, 3, 5, 5, 6, 7, 7, 8,};
1418
1419 if(!testConvertFromUnicode(inputTest, UPRV_LENGTHOF(inputTest),
1420 toIBM943, UPRV_LENGTHOF(toIBM943), "ibm-943",
1421 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offset, NULL, 0 ))
1422 log_err("u-> ibm-943 with substitute did not match.\n");
1423
1424 if(!testConvertFromUnicode(euc_jp_inputText, UPRV_LENGTHOF(euc_jp_inputText),
1425 to_euc_jp, UPRV_LENGTHOF(to_euc_jp), "IBM-eucJP",
1426 UCNV_FROM_U_CALLBACK_SUBSTITUTE, fromEUC_JPOffs, NULL, 0 ))
1427 log_err("u-> euc-jp with substitute did not match.\n");
1428
1429 if(!testConvertFromUnicode(euc_tw_inputText, UPRV_LENGTHOF(euc_tw_inputText),
1430 to_euc_tw, UPRV_LENGTHOF(to_euc_tw), "euc-tw",
1431 UCNV_FROM_U_CALLBACK_SUBSTITUTE, from_euc_twOffs, NULL, 0 ))
1432 log_err("u-> euc-tw with substitute did not match.\n");
1433 }
1434 #endif
1435
1436 log_verbose("Testing fromUnicode for SCSU with UCNV_FROM_U_CALLBACK_SUBSTITUTE \n");
1437 {
1438 UChar SCSU_inputText[]={ 0x0041, 0xd801/*illegal*/, 0x0042, };
1439
1440 const uint8_t to_SCSU[]={
1441 0x41,
1442 0x0e, 0xff,0xfd,
1443 0x42
1444
1445
1446 };
1447 int32_t from_SCSUOffs [] ={
1448 0,
1449 1,1,1,
1450 2,
1451
1452 };
1453 const uint8_t to_SCSU_1[]={
1454 0x41,
1455
1456 };
1457 int32_t from_SCSUOffs_1 [] ={
1458 0,
1459
1460 };
1461 if(!testConvertFromUnicode(SCSU_inputText, UPRV_LENGTHOF(SCSU_inputText),
1462 to_SCSU, UPRV_LENGTHOF(to_SCSU), "SCSU",
1463 UCNV_FROM_U_CALLBACK_SUBSTITUTE, from_SCSUOffs, NULL, 0 ))
1464 log_err("u-> SCSU with substitute did not match.\n");
1465
1466 if(!testConvertFromUnicodeWithContext(SCSU_inputText, UPRV_LENGTHOF(SCSU_inputText),
1467 to_SCSU_1, UPRV_LENGTHOF(to_SCSU_1), "SCSU",
1468 UCNV_FROM_U_CALLBACK_SUBSTITUTE, from_SCSUOffs_1, NULL, 0,"i",U_ILLEGAL_CHAR_FOUND ))
1469 log_err("u-> SCSU with substitute did not match.\n");
1470 }
1471
1472 log_verbose("Testing fromUnicode for UTF-8 with UCNV_FROM_U_CALLBACK_SUBSTITUTE\n");
1473 {
1474 static const UChar testinput[]={ 0x20ac, 0xd801, 0xdc01, 0xdc01, 0xd801, 0xffff, 0x0061,};
1475 static const uint8_t expectedUTF8[]= { 0xe2, 0x82, 0xac,
1476 0xf0, 0x90, 0x90, 0x81,
1477 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd,
1478 0xef, 0xbf, 0xbf, 0x61,
1479
1480 };
1481 static const int32_t offsets[]={ 0, 0, 0, 1, 1, 1, 1, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6 };
1482 if(!testConvertFromUnicode(testinput, UPRV_LENGTHOF(testinput),
1483 expectedUTF8, UPRV_LENGTHOF(expectedUTF8), "utf8",
1484 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offsets, NULL, 0 )) {
1485 log_err("u-> utf8 with substitute did not match.\n");
1486 }
1487 }
1488
1489 log_verbose("Testing fromUnicode for UTF-16 with UCNV_FROM_U_CALLBACK_SUBSTITUTE\n");
1490 {
1491 static const UChar in[]={ 0x0041, 0xfeff };
1492
1493 static const uint8_t out[]={
1494 #if U_IS_BIG_ENDIAN
1495 0xfe, 0xff,
1496 0x00, 0x41,
1497 0xfe, 0xff
1498 #else
1499 0xff, 0xfe,
1500 0x41, 0x00,
1501 0xff, 0xfe
1502 #endif
1503 };
1504 static const int32_t offsets[]={
1505 -1, -1, 0, 0, 1, 1
1506 };
1507
1508 if(!testConvertFromUnicode(in, UPRV_LENGTHOF(in),
1509 out, UPRV_LENGTHOF(out), "UTF-16",
1510 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offsets, NULL, 0)
1511 ) {
1512 log_err("u->UTF-16 with substitute did not match.\n");
1513 }
1514 }
1515
1516 log_verbose("Testing fromUnicode for UTF-32 with UCNV_FROM_U_CALLBACK_SUBSTITUTE\n");
1517 {
1518 static const UChar in[]={ 0x0041, 0xfeff };
1519
1520 static const uint8_t out[]={
1521 #if U_IS_BIG_ENDIAN
1522 0x00, 0x00, 0xfe, 0xff,
1523 0x00, 0x00, 0x00, 0x41,
1524 0x00, 0x00, 0xfe, 0xff
1525 #else
1526 0xff, 0xfe, 0x00, 0x00,
1527 0x41, 0x00, 0x00, 0x00,
1528 0xff, 0xfe, 0x00, 0x00
1529 #endif
1530 };
1531 static const int32_t offsets[]={
1532 -1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1
1533 };
1534
1535 if(!testConvertFromUnicode(in, UPRV_LENGTHOF(in),
1536 out, UPRV_LENGTHOF(out), "UTF-32",
1537 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offsets, NULL, 0)
1538 ) {
1539 log_err("u->UTF-32 with substitute did not match.\n");
1540 }
1541 }
1542
1543 /*to unicode*/
1544
1545 #if !UCONFIG_NO_LEGACY_CONVERSION
1546 if(!testConvertToUnicode(expsubIBM_949, UPRV_LENGTHOF(expsubIBM_949),
1547 IBM_949subtoUnicode, UPRV_LENGTHOF(IBM_949subtoUnicode),"ibm-949",
1548 UCNV_TO_U_CALLBACK_SUBSTITUTE, fromIBM949Offs, NULL, 0 ))
1549 log_err("ibm-949->u with substitute did not match.\n");
1550 if(!testConvertToUnicode(expsubIBM_943, UPRV_LENGTHOF(expsubIBM_943),
1551 IBM_943subtoUnicode, UPRV_LENGTHOF(IBM_943subtoUnicode),"ibm-943",
1552 UCNV_TO_U_CALLBACK_SUBSTITUTE, fromIBM943Offs, NULL, 0 ))
1553 log_err("ibm-943->u with substitute did not match.\n");
1554 if(!testConvertToUnicode(expsubIBM_930, UPRV_LENGTHOF(expsubIBM_930),
1555 IBM_930subtoUnicode, UPRV_LENGTHOF(IBM_930subtoUnicode),"ibm-930",
1556 UCNV_TO_U_CALLBACK_SUBSTITUTE, fromIBM930Offs, NULL, 0 ))
1557 log_err("ibm-930->u with substitute did not match.\n");
1558
1559 log_verbose("Testing toUnicode with UCNV_TO_U_CALLBACK_SUBSTITUTE \n");
1560 {
1561
1562 const uint8_t sampleTxtEBCIDIC_STATEFUL [] ={
1563 0x0e, 0x5d, 0x5f , 0x41, 0x79, 0x41, 0x44
1564 };
1565 UChar EBCIDIC_STATEFUL_toUnicode[] ={ 0x6d63, 0xfffd, 0x03b4
1566 };
1567 int32_t from_EBCIDIC_STATEFULOffsets []={ 1, 3, 5};
1568
1569
1570 /* EUC_JP*/
1571 const uint8_t sampleTxt_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
1572 0x8f, 0xda, 0xa1, /*unassigned*/
1573 0x8e, 0xe0, 0x8a
1574 };
1575 UChar euc_jptoUnicode[]={ 0x0061, 0x4edd, 0x5bec, 0xfffd, 0x00a2, 0x008a };
1576 int32_t from_euc_jpOffs [] ={ 0, 1, 3, 6, 9, 11 };
1577
1578 /*EUC_TW*/
1579 const uint8_t sampleTxt_euc_tw[]={
1580 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
1581 0x8e, 0xaa, 0xbb, 0xcc,/*unassigned*/
1582 0xe6, 0xca, 0x8a,
1583 };
1584 UChar euc_twtoUnicode[]={ 0x0061, 0x2295, 0x5BF2, 0xfffd, 0x8706, 0x8a, };
1585 int32_t from_euc_twOffs [] ={ 0, 1, 3, 7, 11, 13};
1586
1587
1588 if(!testConvertToUnicode(sampleTxtEBCIDIC_STATEFUL, UPRV_LENGTHOF(sampleTxtEBCIDIC_STATEFUL),
1589 EBCIDIC_STATEFUL_toUnicode, UPRV_LENGTHOF(EBCIDIC_STATEFUL_toUnicode),"ibm-930",
1590 UCNV_TO_U_CALLBACK_SUBSTITUTE, from_EBCIDIC_STATEFULOffsets, NULL, 0 ))
1591 log_err("EBCIDIC_STATEFUL->u with substitute did not match.\n");
1592
1593
1594 if(!testConvertToUnicode(sampleTxt_euc_jp, UPRV_LENGTHOF(sampleTxt_euc_jp),
1595 euc_jptoUnicode, UPRV_LENGTHOF(euc_jptoUnicode),"IBM-eucJP",
1596 UCNV_TO_U_CALLBACK_SUBSTITUTE, from_euc_jpOffs, NULL, 0 ))
1597 log_err("euc-jp->u with substitute did not match.\n");
1598
1599
1600 if(!testConvertToUnicode(sampleTxt_euc_tw, UPRV_LENGTHOF(sampleTxt_euc_tw),
1601 euc_twtoUnicode, UPRV_LENGTHOF(euc_twtoUnicode),"euc-tw",
1602 UCNV_TO_U_CALLBACK_SUBSTITUTE, from_euc_twOffs, NULL, 0 ))
1603 log_err("euc-tw->u with substitute did not match.\n");
1604
1605
1606 if(!testConvertToUnicodeWithContext(sampleTxt_euc_jp, UPRV_LENGTHOF(sampleTxt_euc_jp),
1607 euc_jptoUnicode, UPRV_LENGTHOF(euc_jptoUnicode),"IBM-eucJP",
1608 UCNV_TO_U_CALLBACK_SUBSTITUTE, from_euc_jpOffs, NULL, 0 ,"i", U_ILLEGAL_CHAR_FOUND))
1609 log_err("euc-jp->u with substitute did not match.\n");
1610 }
1611 #endif
1612
1613 log_verbose("Testing toUnicode for UTF-8 with UCNV_TO_U_CALLBACK_SUBSTITUTE \n");
1614 {
1615 const uint8_t sampleText1[] = { 0x31, 0xe4, 0xba, 0x8c,
1616 0xe0, 0x80, 0x61,};
1617 UChar expected1[] = { 0x0031, 0x4e8c, 0xfffd, 0xfffd, 0x0061};
1618 int32_t offsets1[] = { 0x0000, 0x0001, 0x0004, 0x0005, 0x0006};
1619
1620 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
1621 expected1, UPRV_LENGTHOF(expected1),"utf8",
1622 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets1, NULL, 0 ))
1623 log_err("utf8->u with substitute did not match.\n");;
1624 }
1625 log_verbose("Testing toUnicode for SCSU with UCNV_TO_U_CALLBACK_SUBSTITUTE \n");
1626 {
1627 const uint8_t sampleText1[] = { 0xba, 0x8c,0xF8, 0x61,0x0c, 0x0c,};
1628 UChar expected1[] = { 0x00ba, 0x008c, 0x00f8, 0x0061,0xfffd,0xfffd};
1629 int32_t offsets1[] = { 0x0000, 0x0001,0x0002,0x0003,4,5};
1630
1631 if(!testConvertToUnicode(sampleText1, UPRV_LENGTHOF(sampleText1),
1632 expected1, UPRV_LENGTHOF(expected1),"SCSU",
1633 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets1, NULL, 0 ))
1634 log_err("scsu->u with stop did not match.\n");;
1635 }
1636
1637 #if !UCONFIG_NO_LEGACY_CONVERSION
1638 log_verbose("Testing ibm-930 subchar/subchar1\n");
1639 {
1640 static const UChar u1[]={ 0x6d63, 0x6d64, 0x6d65, 0x6d66, 0xdf };
1641 static const uint8_t s1[]={ 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0xfe, 0xfe, 0x46, 0x6b, 0x0f, 0x3f };
1642 static const int32_t offsets1[]={ 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4 };
1643
1644 static const UChar u2[]={ 0x6d63, 0x6d64, 0xfffd, 0x6d66, 0x1a };
1645 static const uint8_t s2[]={ 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0xfc, 0xfc, 0x46, 0x6b, 0x0f, 0x57 };
1646 static const int32_t offsets2[]={ 1, 3, 5, 7, 10 };
1647
1648 if(!testConvertFromUnicode(u1, UPRV_LENGTHOF(u1), s1, UPRV_LENGTHOF(s1), "ibm-930",
1649 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offsets1, NULL, 0)
1650 ) {
1651 log_err("u->ibm-930 subchar/subchar1 did not match.\n");
1652 }
1653
1654 if(!testConvertToUnicode(s2, UPRV_LENGTHOF(s2), u2, UPRV_LENGTHOF(u2), "ibm-930",
1655 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets2, NULL, 0)
1656 ) {
1657 log_err("ibm-930->u subchar/subchar1 did not match.\n");
1658 }
1659 }
1660
1661 log_verbose("Testing GB 18030 with substitute callbacks\n");
1662 {
1663 static const UChar u2[]={
1664 0x24, 0x7f, 0x80, 0x1f9, 0x20ac, 0x4e00, 0x9fa6, 0xffff, 0xd800, 0xdc00, 0xfffd, 0xdbff, 0xdfff };
1665 static const uint8_t gb2[]={
1666 0x24, 0x7f, 0x81, 0x30, 0x81, 0x30, 0xa8, 0xbf, 0xa2, 0xe3, 0xd2, 0xbb, 0x82, 0x35, 0x8f, 0x33, 0x84, 0x31, 0xa4, 0x39, 0x90, 0x30, 0x81, 0x30, 0xe3, 0x32, 0x9a, 0x36, 0xe3, 0x32, 0x9a, 0x35 };
1667 static const int32_t offsets2[]={
1668 0, 1, 2, 6, 8, 10, 12, 16, 20, 20, 24, 28, 28 };
1669
1670 if(!testConvertToUnicode(gb2, UPRV_LENGTHOF(gb2), u2, UPRV_LENGTHOF(u2), "gb18030",
1671 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets2, NULL, 0)
1672 ) {
1673 log_err("gb18030->u with substitute did not match.\n");
1674 }
1675 }
1676 #endif
1677
1678 log_verbose("Testing UTF-7 toUnicode with substitute callbacks\n");
1679 {
1680 static const uint8_t utf7[]={
1681 /* a~ a+AB~ a+AB\x0c a+AB- a+AB. a+. */
1682 0x61, 0x7e, 0x61, 0x2b, 0x41, 0x42, 0x7e, 0x61, 0x2b, 0x41, 0x42, 0x0c, 0x61, 0x2b, 0x41, 0x42, 0x2d, 0x61, 0x2b, 0x41, 0x42, 0x2e, 0x61, 0x2b, 0x2e
1683 };
1684 static const UChar unicode[]={
1685 0x61, 0xfffd, 0x61, 0xfffd, 0xfffd, 0x61, 0xfffd, 0xfffd, 0x61, 0xfffd, 0x61, 0xfffd, 0x2e, 0x61, 0xfffd, 0x2e
1686 };
1687 static const int32_t offsets[]={
1688 0, 1, 2, 4, 6, 7, 9, 11, 12, 14, 17, 19, 21, 22, 23, 24
1689 };
1690
1691 if(!testConvertToUnicode(utf7, UPRV_LENGTHOF(utf7), unicode, UPRV_LENGTHOF(unicode), "UTF-7",
1692 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets, NULL, 0)
1693 ) {
1694 log_err("UTF-7->u with substitute did not match.\n");
1695 }
1696 }
1697
1698 log_verbose("Testing UTF-16 toUnicode with substitute callbacks\n");
1699 {
1700 static const uint8_t
1701 in1[]={ 0xfe, 0xff, 0x4e, 0x00, 0xfe, 0xff },
1702 in2[]={ 0xff, 0xfe, 0x4e, 0x00, 0xfe, 0xff },
1703 in3[]={ 0xfe, 0xfd, 0x4e, 0x00, 0xfe, 0xff };
1704
1705 static const UChar
1706 out1[]={ 0x4e00, 0xfeff },
1707 out2[]={ 0x004e, 0xfffe },
1708 out3[]={ 0xfefd, 0x4e00, 0xfeff };
1709
1710 static const int32_t
1711 offsets1[]={ 2, 4 },
1712 offsets2[]={ 2, 4 },
1713 offsets3[]={ 0, 2, 4 };
1714
1715 if(!testConvertToUnicode(in1, UPRV_LENGTHOF(in1), out1, UPRV_LENGTHOF(out1), "UTF-16",
1716 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets1, NULL, 0)
1717 ) {
1718 log_err("UTF-16 (BE BOM)->u with substitute did not match.\n");
1719 }
1720
1721 if(!testConvertToUnicode(in2, UPRV_LENGTHOF(in2), out2, UPRV_LENGTHOF(out2), "UTF-16",
1722 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets2, NULL, 0)
1723 ) {
1724 log_err("UTF-16 (LE BOM)->u with substitute did not match.\n");
1725 }
1726
1727 if(!testConvertToUnicode(in3, UPRV_LENGTHOF(in3), out3, UPRV_LENGTHOF(out3), "UTF-16",
1728 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets3, NULL, 0)
1729 ) {
1730 log_err("UTF-16 (no BOM)->u with substitute did not match.\n");
1731 }
1732 }
1733
1734 log_verbose("Testing UTF-32 toUnicode with substitute callbacks\n");
1735 {
1736 static const uint8_t
1737 in1[]={ 0x00, 0x00, 0xfe, 0xff, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0xfe, 0xff },
1738 in2[]={ 0xff, 0xfe, 0x00, 0x00, 0x00, 0x10, 0x0f, 0x00, 0xfe, 0xff, 0x00, 0x00 },
1739 in3[]={ 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0xd8, 0x40, 0x00, 0x00, 0xdc, 0x01 },
1740 in4[]={ 0x00, 0x01, 0x02, 0x03, 0x00, 0x11, 0x12, 0x00, 0x00, 0x00, 0x4e, 0x00 };
1741
1742 static const UChar
1743 out1[]={ U16_LEAD(0x100f00), U16_TRAIL(0x100f00), 0xfeff },
1744 out2[]={ U16_LEAD(0x0f1000), U16_TRAIL(0x0f1000), 0xfffe },
1745 out3[]={ 0xfefe, U16_LEAD(0x100f00), U16_TRAIL(0x100f00), 0xfffd, 0xfffd },
1746 out4[]={ U16_LEAD(0x10203), U16_TRAIL(0x10203), 0xfffd, 0x4e00 };
1747
1748 static const int32_t
1749 offsets1[]={ 4, 4, 8 },
1750 offsets2[]={ 4, 4, 8 },
1751 offsets3[]={ 0, 4, 4, 8, 12 },
1752 offsets4[]={ 0, 0, 4, 8 };
1753
1754 if(!testConvertToUnicode(in1, UPRV_LENGTHOF(in1), out1, UPRV_LENGTHOF(out1), "UTF-32",
1755 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets1, NULL, 0)
1756 ) {
1757 log_err("UTF-32 (BE BOM)->u with substitute did not match.\n");
1758 }
1759
1760 if(!testConvertToUnicode(in2, UPRV_LENGTHOF(in2), out2, UPRV_LENGTHOF(out2), "UTF-32",
1761 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets2, NULL, 0)
1762 ) {
1763 log_err("UTF-32 (LE BOM)->u with substitute did not match.\n");
1764 }
1765
1766 if(!testConvertToUnicode(in3, UPRV_LENGTHOF(in3), out3, UPRV_LENGTHOF(out3), "UTF-32",
1767 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets3, NULL, 0)
1768 ) {
1769 log_err("UTF-32 (no BOM)->u with substitute did not match.\n");
1770 }
1771
1772 if(!testConvertToUnicode(in4, UPRV_LENGTHOF(in4), out4, UPRV_LENGTHOF(out4), "UTF-32",
1773 UCNV_TO_U_CALLBACK_SUBSTITUTE, offsets4, NULL, 0)
1774 ) {
1775 log_err("UTF-32 (no BOM, with error)->u with substitute did not match.\n");
1776 }
1777 }
1778 }
1779
1780 static void TestSubWithValue(int32_t inputsize, int32_t outputsize)
1781 {
1782 UChar sampleText[] = { 0x0000, 0xAC00, 0xAC01, 0xEF67, 0xD700 };
1783 UChar sampleText2[] = { 0x6D63, 0x6D64, 0x6D65, 0x6D66 };
1784
1785 const uint8_t expsubwvalIBM_949[]= {
1786 0x00, 0xb0, 0xa1, 0xb0, 0xa2,
1787 0x25, 0x55, 0x45, 0x46, 0x36, 0x37, 0xc8, 0xd3 };
1788
1789 const uint8_t expsubwvalIBM_943[]= {
1790 0x9f, 0xaf, 0x9f, 0xb1,
1791 0x25, 0x55, 0x36, 0x44, 0x36, 0x35, 0x89, 0x59 };
1792
1793 const uint8_t expsubwvalIBM_930[] = {
1794 0x0e, 0x5d, 0x5f, 0x5d, 0x63, 0x0f, 0x6c, 0xe4, 0xf6, 0xc4, 0xf6, 0xf5, 0x0e, 0x46, 0x6b, 0x0f };
1795
1796 int32_t toIBM949Offs [] ={ 0, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4 };
1797 int32_t toIBM943Offs [] = { 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3 };
1798 int32_t toIBM930Offs [] = { 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3 }; /* last item: 3,3,3,3 because there's SO+DBCS+SI */
1799
1800 gInBufferSize = inputsize;
1801 gOutBufferSize = outputsize;
1802
1803 /*from Unicode*/
1804
1805 #if !UCONFIG_NO_LEGACY_CONVERSION
1806 if(!testConvertFromUnicode(sampleText, UPRV_LENGTHOF(sampleText),
1807 expsubwvalIBM_949, UPRV_LENGTHOF(expsubwvalIBM_949), "ibm-949",
1808 UCNV_FROM_U_CALLBACK_ESCAPE, toIBM949Offs, NULL, 0 ))
1809 log_err("u-> ibm-949 with subst with value did not match.\n");
1810
1811 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1812 expsubwvalIBM_943, UPRV_LENGTHOF(expsubwvalIBM_943), "ibm-943",
1813 UCNV_FROM_U_CALLBACK_ESCAPE, toIBM943Offs, NULL, 0 ))
1814 log_err("u-> ibm-943 with sub with value did not match.\n");
1815
1816 if(!testConvertFromUnicode(sampleText2, UPRV_LENGTHOF(sampleText2),
1817 expsubwvalIBM_930, UPRV_LENGTHOF(expsubwvalIBM_930), "ibm-930",
1818 UCNV_FROM_U_CALLBACK_ESCAPE, toIBM930Offs, NULL, 0 ))
1819 log_err("u-> ibm-930 with subst with value did not match.\n");
1820
1821
1822 log_verbose("Testing fromUnicode with UCNV_FROM_U_CALLBACK_ESCAPE \n");
1823 {
1824 static const UChar inputTest[] = { 0x0061, 0xd801, 0xdc01, 0xd801, 0x0061 };
1825 static const uint8_t toIBM943[]= { 0x61,
1826 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1827 0x25, 0x55, 0x44, 0x43, 0x30, 0x31,
1828 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1829 0x61 };
1830 static const int32_t offset[]= {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 4};
1831
1832
1833 /* EUC_JP*/
1834 static const UChar euc_jp_inputText[]={ 0x0061, 0x4edd, 0x5bec, 0xd801, 0xdc01, 0xd801, 0x0061, 0x00a2, };
1835 static const uint8_t to_euc_jp[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
1836 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1837 0x25, 0x55, 0x44, 0x43, 0x30, 0x31,
1838 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1839 0x61, 0x8e, 0xe0,
1840 };
1841 static const int32_t fromEUC_JPOffs [] ={ 0, 1, 1, 2, 2, 2,
1842 3, 3, 3, 3, 3, 3,
1843 3, 3, 3, 3, 3, 3,
1844 5, 5, 5, 5, 5, 5,
1845 6, 7, 7,
1846 };
1847
1848 /*EUC_TW*/
1849 static const UChar euc_tw_inputText[]={ 0x0061, 0x2295, 0x5BF2, 0xd801, 0xdc01, 0xd801, 0x0061, 0x8706, 0x8a, };
1850 static const uint8_t to_euc_tw[]={
1851 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
1852 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1853 0x25, 0x55, 0x44, 0x43, 0x30, 0x31,
1854 0x25, 0x55, 0x44, 0x38, 0x30, 0x31,
1855 0x61, 0xe6, 0xca, 0x8a,
1856 };
1857 static const int32_t from_euc_twOffs [] ={ 0, 1, 1, 2, 2, 2, 2,
1858 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 5,
1859 6, 7, 7, 8,
1860 };
1861 /*ISO-2022-JP*/
1862 static const UChar iso_2022_jp_inputText1[]={ 0x3000, 0x00E9, 0x3001,0x00E9, 0x0042} ;
1863 static const uint8_t to_iso_2022_jp1[]={
1864 0x1b, 0x24, 0x42, 0x21, 0x21,
1865 0x1b, 0x28, 0x42, 0x25, 0x55, 0x30, 0x30, 0x45, 0x39,
1866 0x1b, 0x24, 0x42, 0x21, 0x22,
1867 0x1b, 0x28, 0x42, 0x25, 0x55, 0x30, 0x30, 0x45, 0x39,
1868 0x42,
1869 };
1870
1871 static const int32_t from_iso_2022_jpOffs1 [] ={
1872 0,0,0,0,0,
1873 1,1,1,1,1,1,1,1,1,
1874 2,2,2,2,2,
1875 3,3,3,3,3,3,3,3,3,
1876 4,
1877 };
1878 /* surrogate pair*/
1879 static const UChar iso_2022_jp_inputText2[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042} ;
1880 static const uint8_t to_iso_2022_jp2[]={
1881 0x1b, 0x24, 0x42, 0x21, 0x21,
1882 0x1b, 0x28, 0x42, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1883 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1884 0x1b, 0x24, 0x42, 0x21, 0x22,
1885 0x1b, 0x28, 0x42, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1886 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1887 0x42,
1888 };
1889 static const int32_t from_iso_2022_jpOffs2 [] ={
1890 0,0,0,0,0,
1891 1,1,1,1,1,1,1,1,1,
1892 1,1,1,1,1,1,
1893 3,3,3,3,3,
1894 4,4,4,4,4,4,4,4,4,
1895 4,4,4,4,4,4,
1896 6,
1897 };
1898
1899 /*ISO-2022-cn*/
1900 static const UChar iso_2022_cn_inputText[]={ 0x0041, 0x3712, 0x0042, };
1901 static const uint8_t to_iso_2022_cn[]={
1902 0x41,
1903 0x25, 0x55, 0x33, 0x37, 0x31, 0x32,
1904 0x42,
1905 };
1906 static const int32_t from_iso_2022_cnOffs [] ={
1907 0,
1908 1,1,1,1,1,1,
1909 2,
1910 };
1911
1912 static const UChar iso_2022_cn_inputText4[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042};
1913
1914 static const uint8_t to_iso_2022_cn4[]={
1915 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
1916 0x0f, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1917 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1918 0x0e, 0x21, 0x22,
1919 0x0f, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1920 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1921 0x42,
1922 };
1923 static const int32_t from_iso_2022_cnOffs4 [] ={
1924 0,0,0,0,0,0,0,
1925 1,1,1,1,1,1,1,
1926 1,1,1,1,1,1,
1927 3,3,3,
1928 4,4,4,4,4,4,4,
1929 4,4,4,4,4,4,
1930 6
1931
1932 };
1933
1934 /*ISO-2022-kr*/
1935 static const UChar iso_2022_kr_inputText2[]={ 0x0041, 0x03A0,0xD84D, 0xDC56/*unassigned*/,0x03A0, 0x0042,0xD84D, 0xDC56/*unassigned*/,0x43 };
1936 static const uint8_t to_iso_2022_kr2[]={
1937 0x1b, 0x24, 0x29, 0x43,
1938 0x41,
1939 0x0e, 0x25, 0x50,
1940 0x0f, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1941 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1942 0x0e, 0x25, 0x50,
1943 0x0f, 0x42,
1944 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
1945 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
1946 0x43
1947 };
1948 static const int32_t from_iso_2022_krOffs2 [] ={
1949 -1,-1,-1,-1,
1950 0,
1951 1,1,1,
1952 2,2,2,2,2,2,2,
1953 2,2,2,2,2,2,
1954 4,4,4,
1955 5,5,
1956 6,6,6,6,6,6,
1957 6,6,6,6,6,6,
1958 8,
1959 };
1960
1961 static const UChar iso_2022_kr_inputText[]={ 0x0041, 0x03A0,0x3712/*unassigned*/,0x03A0, 0x0042,0x3712/*unassigned*/,0x43 };
1962 static const uint8_t to_iso_2022_kr[]={
1963 0x1b, 0x24, 0x29, 0x43,
1964 0x41,
1965 0x0e, 0x25, 0x50,
1966 0x0f, 0x25, 0x55, 0x33, 0x37, 0x31, 0x32, /*unassigned*/
1967 0x0e, 0x25, 0x50,
1968 0x0f, 0x42,
1969 0x25, 0x55, 0x33, 0x37, 0x31, 0x32, /*unassigned*/
1970 0x43
1971 };
1972
1973
1974 static const int32_t from_iso_2022_krOffs [] ={
1975 -1,-1,-1,-1,
1976 0,
1977 1,1,1,
1978 2,2,2,2,2,2,2,
1979 3,3,3,
1980 4,4,
1981 5,5,5,5,5,5,
1982 6,
1983 };
1984 /* HZ encoding */
1985 static const UChar hz_inputText[]={ 0x0041, 0x03A0,0x0662/*unassigned*/,0x03A0, 0x0042, };
1986
1987 static const uint8_t to_hz[]={
1988 0x7e, 0x7d, 0x41,
1989 0x7e, 0x7b, 0x26, 0x30,
1990 0x7e, 0x7d, 0x25, 0x55, 0x30, 0x36, 0x36, 0x32, /*unassigned*/
1991 0x7e, 0x7b, 0x26, 0x30,
1992 0x7e, 0x7d, 0x42,
1993
1994 };
1995 static const int32_t from_hzOffs [] ={
1996 0,0,0,
1997 1,1,1,1,
1998 2,2,2,2,2,2,2,2,
1999 3,3,3,3,
2000 4,4,4
2001 };
2002
2003 static const UChar hz_inputText2[]={ 0x0041, 0x03A0,0xD84D, 0xDC56/*unassigned*/,0x03A0, 0x0042,0xD84D, 0xDC56/*unassigned*/,0x43 };
2004 static const uint8_t to_hz2[]={
2005 0x7e, 0x7d, 0x41,
2006 0x7e, 0x7b, 0x26, 0x30,
2007 0x7e, 0x7d, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
2008 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
2009 0x7e, 0x7b, 0x26, 0x30,
2010 0x7e, 0x7d, 0x42,
2011 0x25, 0x55, 0x44, 0x38, 0x34, 0x44,
2012 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
2013 0x43
2014 };
2015 static const int32_t from_hzOffs2 [] ={
2016 0,0,0,
2017 1,1,1,1,
2018 2,2,2,2,2,2,2,2,
2019 2,2,2,2,2,2,
2020 4,4,4,4,
2021 5,5,5,
2022 6,6,6,6,6,6,
2023 6,6,6,6,6,6,
2024 8,
2025 };
2026
2027 /*ISCII*/
2028 static const UChar iscii_inputText[]={ 0x0041, 0x0901,0x3712/*unassigned*/,0x0902, 0x0042,0x3712/*unassigned*/,0x43 };
2029 static const uint8_t to_iscii[]={
2030 0x41,
2031 0xef, 0x42, 0xa1,
2032 0x25, 0x55, 0x33, 0x37, 0x31, 0x32, /*unassigned*/
2033 0xa2,
2034 0x42,
2035 0x25, 0x55, 0x33, 0x37, 0x31, 0x32, /*unassigned*/
2036 0x43
2037 };
2038
2039
2040 static const int32_t from_isciiOffs [] ={
2041 0,
2042 1,1,1,
2043 2,2,2,2,2,2,
2044 3,
2045 4,
2046 5,5,5,5,5,5,
2047 6,
2048 };
2049
2050 if(!testConvertFromUnicode(inputTest, UPRV_LENGTHOF(inputTest),
2051 toIBM943, UPRV_LENGTHOF(toIBM943), "ibm-943",
2052 UCNV_FROM_U_CALLBACK_ESCAPE, offset, NULL, 0 ))
2053 log_err("u-> ibm-943 with subst with value did not match.\n");
2054
2055 if(!testConvertFromUnicode(euc_jp_inputText, UPRV_LENGTHOF(euc_jp_inputText),
2056 to_euc_jp, UPRV_LENGTHOF(to_euc_jp), "IBM-eucJP",
2057 UCNV_FROM_U_CALLBACK_ESCAPE, fromEUC_JPOffs, NULL, 0 ))
2058 log_err("u-> euc-jp with subst with value did not match.\n");
2059
2060 if(!testConvertFromUnicode(euc_tw_inputText, UPRV_LENGTHOF(euc_tw_inputText),
2061 to_euc_tw, UPRV_LENGTHOF(to_euc_tw), "euc-tw",
2062 UCNV_FROM_U_CALLBACK_ESCAPE, from_euc_twOffs, NULL, 0 ))
2063 log_err("u-> euc-tw with subst with value did not match.\n");
2064
2065 if(!testConvertFromUnicode(iso_2022_jp_inputText1, UPRV_LENGTHOF(iso_2022_jp_inputText1),
2066 to_iso_2022_jp1, UPRV_LENGTHOF(to_iso_2022_jp1), "iso-2022-jp",
2067 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs1, NULL, 0 ))
2068 log_err("u-> iso_2022_jp with subst with value did not match.\n");
2069
2070 if(!testConvertFromUnicode(iso_2022_jp_inputText1, UPRV_LENGTHOF(iso_2022_jp_inputText1),
2071 to_iso_2022_jp1, UPRV_LENGTHOF(to_iso_2022_jp1), "iso-2022-jp",
2072 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs1, NULL, 0 ))
2073 log_err("u-> iso_2022_jp with subst with value did not match.\n");
2074
2075 if(!testConvertFromUnicode(iso_2022_jp_inputText2, UPRV_LENGTHOF(iso_2022_jp_inputText2),
2076 to_iso_2022_jp2, UPRV_LENGTHOF(to_iso_2022_jp2), "iso-2022-jp",
2077 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs2, NULL, 0 ))
2078 log_err("u-> iso_2022_jp with subst with value did not match.\n");
2079 /*ESCAPE OPTIONS*/
2080 {
2081 /* surrogate pair*/
2082 static const UChar iso_2022_jp_inputText3[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042,0x0901c } ;
2083 static const uint8_t to_iso_2022_jp3_v2[]={
2084 0x1b, 0x24, 0x42, 0x21, 0x21,
2085 0x1b, 0x28, 0x42, 0x26, 0x23, 0x31, 0x34, 0x34, 0x34, 0x37, 0x30, 0x3b,
2086
2087 0x1b, 0x24, 0x42, 0x21, 0x22,
2088 0x1b, 0x28, 0x42, 0x26, 0x23, 0x31, 0x34, 0x34, 0x34, 0x37, 0x30, 0x3b,
2089
2090 0x42,
2091 0x26, 0x23, 0x33, 0x36, 0x38, 0x39, 0x32, 0x3b,
2092 };
2093
2094 static const int32_t from_iso_2022_jpOffs3_v2 [] ={
2095 0,0,0,0,0,
2096 1,1,1,1,1,1,1,1,1,1,1,1,
2097
2098 3,3,3,3,3,
2099 4,4,4,4,4,4,4,4,4,4,4,4,
2100
2101 6,
2102 7,7,7,7,7,7,7,7,7
2103 };
2104
2105 if(!testConvertFromUnicodeWithContext(iso_2022_jp_inputText3, UPRV_LENGTHOF(iso_2022_jp_inputText3),
2106 to_iso_2022_jp3_v2, UPRV_LENGTHOF(to_iso_2022_jp3_v2), "iso-2022-jp",
2107 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs3_v2, NULL, 0,UCNV_ESCAPE_XML_DEC,U_ZERO_ERROR ))
2108 log_err("u-> iso-2022-jp with sub & UCNV_ESCAPE_XML_DEC did not match.\n");
2109 }
2110 {
2111 static const UChar iso_2022_cn_inputText5[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042,0x0902};
2112 static const uint8_t to_iso_2022_cn5_v2[]={
2113 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
2114 0x0f, 0x5c, 0x75, 0x44, 0x38, 0x34, 0x44,
2115 0x5c, 0x75, 0x44, 0x43, 0x35, 0x36,
2116 0x0e, 0x21, 0x22,
2117 0x0f, 0x5c, 0x75, 0x44, 0x38, 0x34, 0x44,
2118 0x5c, 0x75, 0x44, 0x43, 0x35, 0x36,
2119 0x42,
2120 0x5c, 0x75, 0x30, 0x39, 0x30, 0x32,
2121 };
2122 static const int32_t from_iso_2022_cnOffs5_v2 [] ={
2123 0,0,0,0,0,0,0,
2124 1,1,1,1,1,1,1,
2125 1,1,1,1,1,1,
2126 3,3,3,
2127 4,4,4,4,4,4,4,
2128 4,4,4,4,4,4,
2129 6,
2130 7,7,7,7,7,7
2131 };
2132 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText5, UPRV_LENGTHOF(iso_2022_cn_inputText5),
2133 to_iso_2022_cn5_v2, UPRV_LENGTHOF(to_iso_2022_cn5_v2), "iso-2022-cn",
2134 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs5_v2, NULL, 0,UCNV_ESCAPE_JAVA,U_ZERO_ERROR ))
2135 log_err("u-> iso-2022-cn with sub & UCNV_ESCAPE_JAVA did not match.\n");
2136
2137 }
2138 {
2139 static const UChar iso_2022_cn_inputText6[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042,0x0902};
2140 static const uint8_t to_iso_2022_cn6_v2[]={
2141 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
2142 0x0f, 0x7b, 0x55, 0x2b, 0x32, 0x33, 0x34, 0x35, 0x36, 0x7d,
2143 0x0e, 0x21, 0x22,
2144 0x0f, 0x7b, 0x55, 0x2b, 0x32, 0x33, 0x34, 0x35, 0x36, 0x7d,
2145 0x42,
2146 0x7b, 0x55, 0x2b, 0x30, 0x39, 0x30, 0x32, 0x7d
2147 };
2148 static const int32_t from_iso_2022_cnOffs6_v2 [] ={
2149 0, 0, 0, 0, 0, 0, 0,
2150 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2151 3, 3, 3,
2152 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2153 6,
2154 7, 7, 7, 7, 7, 7, 7, 7,
2155 };
2156 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText6, UPRV_LENGTHOF(iso_2022_cn_inputText6),
2157 to_iso_2022_cn6_v2, UPRV_LENGTHOF(to_iso_2022_cn6_v2), "iso-2022-cn",
2158 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs6_v2, NULL, 0,UCNV_ESCAPE_UNICODE,U_ZERO_ERROR ))
2159 log_err("u-> iso-2022-cn with sub & UCNV_ESCAPE_UNICODE did not match.\n");
2160
2161 }
2162 {
2163 static const UChar iso_2022_cn_inputText7[]={ 0x3000, 0xD84D, 0xDC56, 0x3001,0xD84D,0xDC56, 0x0042,0x0902};
2164 static const uint8_t to_iso_2022_cn7_v2[]={
2165 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
2166 0x0f, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44, 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
2167 0x0e, 0x21, 0x22,
2168 0x0f, 0x25, 0x55, 0x44, 0x38, 0x34, 0x44, 0x25, 0x55, 0x44, 0x43, 0x35, 0x36,
2169 0x42, 0x25, 0x55, 0x30, 0x39, 0x30, 0x32,
2170 };
2171 static const int32_t from_iso_2022_cnOffs7_v2 [] ={
2172 0, 0, 0, 0, 0, 0, 0,
2173 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2174 3, 3, 3,
2175 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2176 6,
2177 7, 7, 7, 7, 7, 7,
2178 };
2179 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText7, UPRV_LENGTHOF(iso_2022_cn_inputText7),
2180 to_iso_2022_cn7_v2, UPRV_LENGTHOF(to_iso_2022_cn7_v2), "iso-2022-cn",
2181 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs7_v2, NULL, 0,"K" ,U_ZERO_ERROR ))
2182 log_err("u-> iso-2022-cn with sub & K did not match.\n");
2183
2184 }
2185 {
2186 static const UChar iso_2022_cn_inputText8[]={
2187 0x3000,
2188 0xD84D, 0xDC56,
2189 0x3001,
2190 0xD84D, 0xDC56,
2191 0xDBFF, 0xDFFF,
2192 0x0042,
2193 0x0902};
2194 static const uint8_t to_iso_2022_cn8_v2[]={
2195 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
2196 0x0f, 0x5c, 0x32, 0x33, 0x34, 0x35, 0x36, 0x20,
2197 0x0e, 0x21, 0x22,
2198 0x0f, 0x5c, 0x32, 0x33, 0x34, 0x35, 0x36, 0x20,
2199 0x5c, 0x31, 0x30, 0x46, 0x46, 0x46, 0x46, 0x20,
2200 0x42,
2201 0x5c, 0x39, 0x30, 0x32, 0x20
2202 };
2203 static const int32_t from_iso_2022_cnOffs8_v2 [] ={
2204 0, 0, 0, 0, 0, 0, 0,
2205 1, 1, 1, 1, 1, 1, 1, 1,
2206 3, 3, 3,
2207 4, 4, 4, 4, 4, 4, 4, 4,
2208 6, 6, 6, 6, 6, 6, 6, 6,
2209 8,
2210 9, 9, 9, 9, 9
2211 };
2212 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText8, UPRV_LENGTHOF(iso_2022_cn_inputText8),
2213 to_iso_2022_cn8_v2, UPRV_LENGTHOF(to_iso_2022_cn8_v2), "iso-2022-cn",
2214 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs8_v2, NULL, 0,UCNV_ESCAPE_CSS2,U_ZERO_ERROR ))
2215 log_err("u-> iso-2022-cn with sub & UCNV_ESCAPE_CSS2 did not match.\n");
2216
2217 }
2218 {
2219 static const uint8_t to_iso_2022_cn4_v3[]={
2220 0x1b, 0x24, 0x29, 0x41, 0x0e, 0x21, 0x21,
2221 0x0f, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x32, 0x33, 0x34, 0x35, 0x36,
2222 0x0e, 0x21, 0x22,
2223 0x0f, 0x5c, 0x55, 0x30, 0x30, 0x30, 0x32, 0x33, 0x34, 0x35, 0x36,
2224 0x42
2225 };
2226
2227
2228 static const int32_t from_iso_2022_cnOffs4_v3 [] ={
2229 0,0,0,0,0,0,0,
2230 1,1,1,1,1,1,1,1,1,1,1,
2231
2232 3,3,3,
2233 4,4,4,4,4,4,4,4,4,4,4,
2234
2235 6
2236
2237 };
2238 if(!testConvertFromUnicodeWithContext(iso_2022_cn_inputText4, UPRV_LENGTHOF(iso_2022_cn_inputText4),
2239 to_iso_2022_cn4_v3, UPRV_LENGTHOF(to_iso_2022_cn4_v3), "iso-2022-cn",
2240 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs4_v3, NULL, 0,UCNV_ESCAPE_C,U_ZERO_ERROR ))
2241 {
2242 log_err("u-> iso-2022-cn with skip & UCNV_ESCAPE_C did not match.\n");
2243 }
2244 }
2245 if(!testConvertFromUnicode(iso_2022_cn_inputText, UPRV_LENGTHOF(iso_2022_cn_inputText),
2246 to_iso_2022_cn, UPRV_LENGTHOF(to_iso_2022_cn), "iso-2022-cn",
2247 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs, NULL, 0 ))
2248 log_err("u-> iso_2022_cn with subst with value did not match.\n");
2249
2250 if(!testConvertFromUnicode(iso_2022_cn_inputText4, UPRV_LENGTHOF(iso_2022_cn_inputText4),
2251 to_iso_2022_cn4, UPRV_LENGTHOF(to_iso_2022_cn4), "iso-2022-cn",
2252 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs4, NULL, 0 ))
2253 log_err("u-> iso_2022_cn with subst with value did not match.\n");
2254 if(!testConvertFromUnicode(iso_2022_kr_inputText, UPRV_LENGTHOF(iso_2022_kr_inputText),
2255 to_iso_2022_kr, UPRV_LENGTHOF(to_iso_2022_kr), "iso-2022-kr",
2256 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_krOffs, NULL, 0 ))
2257 log_err("u-> iso_2022_kr with subst with value did not match.\n");
2258 if(!testConvertFromUnicode(iso_2022_kr_inputText2, UPRV_LENGTHOF(iso_2022_kr_inputText2),
2259 to_iso_2022_kr2, UPRV_LENGTHOF(to_iso_2022_kr2), "iso-2022-kr",
2260 UCNV_FROM_U_CALLBACK_ESCAPE, from_iso_2022_krOffs2, NULL, 0 ))
2261 log_err("u-> iso_2022_kr2 with subst with value did not match.\n");
2262 if(!testConvertFromUnicode(hz_inputText, UPRV_LENGTHOF(hz_inputText),
2263 to_hz, UPRV_LENGTHOF(to_hz), "HZ",
2264 UCNV_FROM_U_CALLBACK_ESCAPE, from_hzOffs, NULL, 0 ))
2265 log_err("u-> hz with subst with value did not match.\n");
2266 if(!testConvertFromUnicode(hz_inputText2, UPRV_LENGTHOF(hz_inputText2),
2267 to_hz2, UPRV_LENGTHOF(to_hz2), "HZ",
2268 UCNV_FROM_U_CALLBACK_ESCAPE, from_hzOffs2, NULL, 0 ))
2269 log_err("u-> hz with subst with value did not match.\n");
2270
2271 if(!testConvertFromUnicode(iscii_inputText, UPRV_LENGTHOF(iscii_inputText),
2272 to_iscii, UPRV_LENGTHOF(to_iscii), "ISCII,version=0",
2273 UCNV_FROM_U_CALLBACK_ESCAPE, from_isciiOffs, NULL, 0 ))
2274 log_err("u-> iscii with subst with value did not match.\n");
2275 }
2276 #endif
2277
2278 log_verbose("Testing toUnicode with UCNV_TO_U_CALLBACK_ESCAPE \n");
2279 /*to Unicode*/
2280 {
2281 #if !UCONFIG_NO_LEGACY_CONVERSION
2282 static const uint8_t sampleTxtToU[]= { 0x00, 0x9f, 0xaf,
2283 0x81, 0xad, /*unassigned*/
2284 0x89, 0xd3 };
2285 static const UChar IBM_943toUnicode[] = { 0x0000, 0x6D63,
2286 0x25, 0x58, 0x38, 0x31, 0x25, 0x58, 0x41, 0x44,
2287 0x7B87};
2288 static const int32_t fromIBM943Offs [] = { 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 5};
2289
2290 /* EUC_JP*/
2291 static const uint8_t sampleTxt_EUC_JP[]={ 0x61, 0xa1, 0xb8, 0x8f, 0xf4, 0xae,
2292 0x8f, 0xda, 0xa1, /*unassigned*/
2293 0x8e, 0xe0,
2294 };
2295 static const UChar EUC_JPtoUnicode[]={ 0x0061, 0x4edd, 0x5bec,
2296 0x25, 0x58, 0x38, 0x46, 0x25, 0x58, 0x44, 0x41, 0x25, 0x58, 0x41, 0x31,
2297 0x00a2 };
2298 static const int32_t fromEUC_JPOffs [] ={ 0, 1, 3,
2299 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
2300 9,
2301 };
2302
2303 /*EUC_TW*/
2304 static const uint8_t sampleTxt_euc_tw[]={
2305 0x61, 0xa2, 0xd3, 0x8e, 0xa2, 0xdc, 0xe5,
2306 0x8e, 0xaa, 0xbb, 0xcc,/*unassigned*/
2307 0xe6, 0xca, 0x8a,
2308 };
2309 static const UChar euc_twtoUnicode[]={ 0x0061, 0x2295, 0x5BF2,
2310 0x25, 0x58, 0x38, 0x45, 0x25, 0x58, 0x41, 0x41, 0x25, 0x58, 0x42, 0x42, 0x25, 0x58, 0x43, 0x43,
2311 0x8706, 0x8a, };
2312 static const int32_t from_euc_twOffs [] ={ 0, 1, 3,
2313 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
2314 11, 13};
2315
2316 /*iso-2022-jp*/
2317 static const uint8_t sampleTxt_iso_2022_jp[]={
2318 0x1b, 0x28, 0x42, 0x41,
2319 0x1b, 0x24, 0x42, 0x3a, 0x1a, /*unassigned*/
2320 0x1b, 0x28, 0x42, 0x42,
2321
2322 };
2323 /* A % X 3 A % X 1 A B */
2324 static const UChar iso_2022_jptoUnicode[]={ 0x41,0x25,0x58,0x33,0x41,0x25,0x58,0x31,0x41, 0x42 };
2325 static const int32_t from_iso_2022_jpOffs [] ={ 3, 7, 7, 7, 7, 7, 7, 7, 7, 12 };
2326
2327 /*iso-2022-cn*/
2328 static const uint8_t sampleTxt_iso_2022_cn[]={
2329 0x0f, 0x41, 0x44,
2330 0x1B, 0x24, 0x29, 0x47,
2331 0x0E, 0x40, 0x6c, /*unassigned*/
2332 0x0f, 0x42,
2333
2334 };
2335 static const UChar iso_2022_cntoUnicode[]={ 0x41, 0x44,0x25,0x58,0x34,0x30,0x25,0x58,0x36,0x43,0x42 };
2336 static const int32_t from_iso_2022_cnOffs [] ={ 1, 2, 8, 8, 8, 8, 8, 8, 8, 8, 11 };
2337
2338 /*iso-2022-kr*/
2339 static const uint8_t sampleTxt_iso_2022_kr[]={
2340 0x1b, 0x24, 0x29, 0x43,
2341 0x41,
2342 0x0E, 0x7f, 0x1E,
2343 0x0e, 0x25, 0x50,
2344 0x0f, 0x51,
2345 0x42, 0x43,
2346
2347 };
2348 static const UChar iso_2022_krtoUnicode[]={ 0x41,0x25,0x58,0x37,0x46,0x25,0x58,0x31,0x45,0x03A0,0x51, 0x42,0x43};
2349 static const int32_t from_iso_2022_krOffs [] ={ 4, 6, 6, 6, 6, 6, 6, 6, 6, 9, 12, 13 , 14 };
2350
2351 /*hz*/
2352 static const uint8_t sampleTxt_hz[]={
2353 0x41,
2354 0x7e, 0x7b, 0x26, 0x30,
2355 0x7f, 0x1E, /*unassigned*/
2356 0x26, 0x30,
2357 0x7e, 0x7d, 0x42,
2358 0x7e, 0x7b, 0x7f, 0x1E,/*unassigned*/
2359 0x7e, 0x7d, 0x42,
2360 };
2361 static const UChar hztoUnicode[]={
2362 0x41,
2363 0x03a0,
2364 0x25,0x58,0x37,0x46,0x25,0x58,0x31,0x45,
2365 0x03A0,
2366 0x42,
2367 0x25,0x58,0x37,0x46,0x25,0x58,0x31,0x45,
2368 0x42,};
2369
2370 static const int32_t from_hzOffs [] ={0,3,5,5,5,5,5,5,5,5,7,11,14,14,14,14,14,14,14,14,18, };
2371
2372
2373 /*iscii*/
2374 static const uint8_t sampleTxt_iscii[]={
2375 0x41,
2376 0x30,
2377 0xEB, /*unassigned*/
2378 0xa3,
2379 0x42,
2380 0xEC, /*unassigned*/
2381 0x42,
2382 };
2383 static const UChar isciitoUnicode[]={
2384 0x41,
2385 0x30,
2386 0x25, 0x58, 0x45, 0x42,
2387 0x0903,
2388 0x42,
2389 0x25, 0x58, 0x45, 0x43,
2390 0x42,};
2391
2392 static const int32_t from_isciiOffs [] ={0,1,2,2,2,2,3,4,5,5,5,5,6 };
2393 #endif
2394
2395 /*UTF8*/
2396 static const uint8_t sampleTxtUTF8[]={
2397 0x20, 0x64, 0x50,
2398 0xC2, 0x7E, /* truncated char */
2399 0x20,
2400 0xE0, 0xB5, 0x7E, /* truncated char */
2401 0x40,
2402 };
2403 static const UChar UTF8ToUnicode[]={
2404 0x0020, 0x0064, 0x0050,
2405 0x0025, 0x0058, 0x0043, 0x0032, 0x007E, /* \xC2~ */
2406 0x0020,
2407 0x0025, 0x0058, 0x0045, 0x0030, 0x0025, 0x0058, 0x0042, 0x0035, 0x007E,
2408 0x0040
2409 };
2410 static const int32_t fromUTF8[] = {
2411 0, 1, 2,
2412 3, 3, 3, 3, 4,
2413 5,
2414 6, 6, 6, 6, 6, 6, 6, 6, 8,
2415 9
2416 };
2417 static const UChar UTF8ToUnicodeXML_DEC[]={
2418 0x0020, 0x0064, 0x0050,
2419 0x0026, 0x0023, 0x0031, 0x0039, 0x0034, 0x003B, 0x007E, /* &#194;~ */
2420 0x0020,
2421 0x0026, 0x0023, 0x0032, 0x0032, 0x0034, 0x003B, 0x0026, 0x0023, 0x0031, 0x0038, 0x0031, 0x003B, 0x007E,
2422 0x0040
2423 };
2424 static const int32_t fromUTF8XML_DEC[] = {
2425 0, 1, 2,
2426 3, 3, 3, 3, 3, 3, 4,
2427 5,
2428 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8,
2429 9
2430 };
2431
2432
2433 #if !UCONFIG_NO_LEGACY_CONVERSION
2434 if(!testConvertToUnicode(sampleTxtToU, UPRV_LENGTHOF(sampleTxtToU),
2435 IBM_943toUnicode, UPRV_LENGTHOF(IBM_943toUnicode),"ibm-943",
2436 UCNV_TO_U_CALLBACK_ESCAPE, fromIBM943Offs, NULL, 0 ))
2437 log_err("ibm-943->u with substitute with value did not match.\n");
2438
2439 if(!testConvertToUnicode(sampleTxt_EUC_JP, UPRV_LENGTHOF(sampleTxt_EUC_JP),
2440 EUC_JPtoUnicode, UPRV_LENGTHOF(EUC_JPtoUnicode),"IBM-eucJP",
2441 UCNV_TO_U_CALLBACK_ESCAPE, fromEUC_JPOffs, NULL, 0))
2442 log_err("euc-jp->u with substitute with value did not match.\n");
2443
2444 if(!testConvertToUnicode(sampleTxt_euc_tw, UPRV_LENGTHOF(sampleTxt_euc_tw),
2445 euc_twtoUnicode, UPRV_LENGTHOF(euc_twtoUnicode),"euc-tw",
2446 UCNV_TO_U_CALLBACK_ESCAPE, from_euc_twOffs, NULL, 0))
2447 log_err("euc-tw->u with substitute with value did not match.\n");
2448
2449 if(!testConvertToUnicode(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
2450 iso_2022_jptoUnicode, UPRV_LENGTHOF(iso_2022_jptoUnicode),"iso-2022-jp",
2451 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs, NULL, 0))
2452 log_err("iso-2022-jp->u with substitute with value did not match.\n");
2453
2454 if(!testConvertToUnicodeWithContext(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
2455 iso_2022_jptoUnicode, UPRV_LENGTHOF(iso_2022_jptoUnicode),"iso-2022-jp",
2456 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_jpOffs, NULL, 0,"K",U_ZERO_ERROR))
2457 log_err("iso-2022-jp->u with substitute with value did not match.\n");
2458
2459 {/* test UCNV_TO_U_CALLBACK_ESCAPE with options */
2460 {
2461 static const UChar iso_2022_jptoUnicodeDec[]={
2462 0x0041,
2463 /* & # 5 8 ; */
2464 0x0026, 0x0023, 0x0035, 0x0038, 0x003b,
2465 0x0026, 0x0023, 0x0032, 0x0036, 0x003b,
2466 0x0042 };
2467 static const int32_t from_iso_2022_jpOffsDec [] ={ 3,7,7,7,7,7,7,7,7,7,7,12, };
2468 if(!testConvertToUnicodeWithContext(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
2469 iso_2022_jptoUnicodeDec, UPRV_LENGTHOF(iso_2022_jptoUnicodeDec),"iso-2022-jp",
2470 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_jpOffsDec, NULL, 0,UCNV_ESCAPE_XML_DEC,U_ZERO_ERROR ))
2471 log_err("iso-2022-jp->u with substitute with value and UCNV_ESCAPE_XML_DEC did not match.\n");
2472 }
2473 {
2474 static const UChar iso_2022_jptoUnicodeHex[]={
2475 0x0041,
2476 /* & # x 3 A ; */
2477 0x0026, 0x0023, 0x0078, 0x0033, 0x0041, 0x003b,
2478 0x0026, 0x0023, 0x0078, 0x0031, 0x0041, 0x003b,
2479 0x0042 };
2480 static const int32_t from_iso_2022_jpOffsHex [] ={ 3,7,7,7,7,7,7,7,7,7,7,7,7,12 };
2481 if(!testConvertToUnicodeWithContext(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
2482 iso_2022_jptoUnicodeHex, UPRV_LENGTHOF(iso_2022_jptoUnicodeHex),"iso-2022-jp",
2483 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_jpOffsHex, NULL, 0,UCNV_ESCAPE_XML_HEX,U_ZERO_ERROR ))
2484 log_err("iso-2022-jp->u with substitute with value and UCNV_ESCAPE_XML_HEX did not match.\n");
2485 }
2486 {
2487 static const UChar iso_2022_jptoUnicodeC[]={
2488 0x0041,
2489 0x005C, 0x0078, 0x0033, 0x0041, /* \x3A */
2490 0x005C, 0x0078, 0x0031, 0x0041, /* \x1A */
2491 0x0042 };
2492 int32_t from_iso_2022_jpOffsC [] ={ 3,7,7,7,7,7,7,7,7,12 };
2493 if(!testConvertToUnicodeWithContext(sampleTxt_iso_2022_jp, UPRV_LENGTHOF(sampleTxt_iso_2022_jp),
2494 iso_2022_jptoUnicodeC, UPRV_LENGTHOF(iso_2022_jptoUnicodeC),"iso-2022-jp",
2495 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_jpOffsC, NULL, 0,UCNV_ESCAPE_C,U_ZERO_ERROR ))
2496 log_err("iso-2022-jp->u with substitute with value and UCNV_ESCAPE_C did not match.\n");
2497 }
2498 }
2499 if(!testConvertToUnicode(sampleTxt_iso_2022_cn, UPRV_LENGTHOF(sampleTxt_iso_2022_cn),
2500 iso_2022_cntoUnicode, UPRV_LENGTHOF(iso_2022_cntoUnicode),"iso-2022-cn",
2501 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_cnOffs, NULL, 0))
2502 log_err("iso-2022-cn->u with substitute with value did not match.\n");
2503
2504 if(!testConvertToUnicode(sampleTxt_iso_2022_kr, UPRV_LENGTHOF(sampleTxt_iso_2022_kr),
2505 iso_2022_krtoUnicode, UPRV_LENGTHOF(iso_2022_krtoUnicode),"iso-2022-kr",
2506 UCNV_TO_U_CALLBACK_ESCAPE, from_iso_2022_krOffs, NULL, 0))
2507 log_err("iso-2022-kr->u with substitute with value did not match.\n");
2508
2509 if(!testConvertToUnicode(sampleTxt_hz, UPRV_LENGTHOF(sampleTxt_hz),
2510 hztoUnicode, UPRV_LENGTHOF(hztoUnicode),"HZ",
2511 UCNV_TO_U_CALLBACK_ESCAPE, from_hzOffs, NULL, 0))
2512 log_err("hz->u with substitute with value did not match.\n");
2513
2514 if(!testConvertToUnicode(sampleTxt_iscii, UPRV_LENGTHOF(sampleTxt_iscii),
2515 isciitoUnicode, UPRV_LENGTHOF(isciitoUnicode),"ISCII,version=0",
2516 UCNV_TO_U_CALLBACK_ESCAPE, from_isciiOffs, NULL, 0))
2517 log_err("ISCII ->u with substitute with value did not match.\n");
2518 #endif
2519
2520 if(!testConvertToUnicode(sampleTxtUTF8, UPRV_LENGTHOF(sampleTxtUTF8),
2521 UTF8ToUnicode, UPRV_LENGTHOF(UTF8ToUnicode),"UTF-8",
2522 UCNV_TO_U_CALLBACK_ESCAPE, fromUTF8, NULL, 0))
2523 log_err("UTF8->u with UCNV_TO_U_CALLBACK_ESCAPE with value did not match.\n");
2524 if(!testConvertToUnicodeWithContext(sampleTxtUTF8, UPRV_LENGTHOF(sampleTxtUTF8),
2525 UTF8ToUnicodeXML_DEC, UPRV_LENGTHOF(UTF8ToUnicodeXML_DEC),"UTF-8",
2526 UCNV_TO_U_CALLBACK_ESCAPE, fromUTF8XML_DEC, NULL, 0, UCNV_ESCAPE_XML_DEC, U_ZERO_ERROR))
2527 log_err("UTF8->u with UCNV_TO_U_CALLBACK_ESCAPE with value did not match.\n");
2528 }
2529 }
2530
2531 #if !UCONFIG_NO_LEGACY_CONVERSION
2532 static void TestLegalAndOthers(int32_t inputsize, int32_t outputsize)
2533 {
2534 static const UChar legalText[] = { 0x0000, 0xAC00, 0xAC01, 0xD700 };
2535 static const uint8_t templegal949[] ={ 0x00, 0xb0, 0xa1, 0xb0, 0xa2, 0xc8, 0xd3 };
2536 static const int32_t to949legal[] = {0, 1, 1, 2, 2, 3, 3};
2537
2538
2539 static const uint8_t text943[] = {
2540 0x82, 0xa9, 0x82, 0x20, 0x61, 0x8a, 0xbf, 0x8e, 0x9a };
2541 static const UChar toUnicode943sub[] = { 0x304b, 0x1a, 0x20, 0x0061, 0x6f22, 0x5b57 };
2542 static const UChar toUnicode943skip[]= { 0x304b, 0x20, 0x0061, 0x6f22, 0x5b57 };
2543 static const UChar toUnicode943stop[]= { 0x304b};
2544
2545 static const int32_t fromIBM943Offssub[] = { 0, 2, 3, 4, 5, 7 };
2546 static const int32_t fromIBM943Offsskip[] = { 0, 3, 4, 5, 7 };
2547 static const int32_t fromIBM943Offsstop[] = { 0};
2548
2549 gInBufferSize = inputsize;
2550 gOutBufferSize = outputsize;
2551 /*checking with a legal value*/
2552 if(!testConvertFromUnicode(legalText, UPRV_LENGTHOF(legalText),
2553 templegal949, UPRV_LENGTHOF(templegal949), "ibm-949",
2554 UCNV_FROM_U_CALLBACK_SKIP, to949legal, NULL, 0 ))
2555 log_err("u-> ibm-949 with skip did not match.\n");
2556
2557 /*checking illegal value for ibm-943 with substitute*/
2558 if(!testConvertToUnicode(text943, UPRV_LENGTHOF(text943),
2559 toUnicode943sub, UPRV_LENGTHOF(toUnicode943sub),"ibm-943",
2560 UCNV_TO_U_CALLBACK_SUBSTITUTE, fromIBM943Offssub, NULL, 0 ))
2561 log_err("ibm-943->u with subst did not match.\n");
2562 /*checking illegal value for ibm-943 with skip */
2563 if(!testConvertToUnicode(text943, UPRV_LENGTHOF(text943),
2564 toUnicode943skip, UPRV_LENGTHOF(toUnicode943skip),"ibm-943",
2565 UCNV_TO_U_CALLBACK_SKIP, fromIBM943Offsskip, NULL, 0 ))
2566 log_err("ibm-943->u with skip did not match.\n");
2567
2568 /*checking illegal value for ibm-943 with stop */
2569 if(!testConvertToUnicode(text943, UPRV_LENGTHOF(text943),
2570 toUnicode943stop, UPRV_LENGTHOF(toUnicode943stop),"ibm-943",
2571 UCNV_TO_U_CALLBACK_STOP, fromIBM943Offsstop, NULL, 0 ))
2572 log_err("ibm-943->u with stop did not match.\n");
2573
2574 }
2575
2576 static void TestSingleByte(int32_t inputsize, int32_t outputsize)
2577 {
2578 static const uint8_t sampleText[] = {
2579 0x82, 0xa9, 0x61, 0x62, 0x63 , 0x82,
2580 0xff, 0x32, 0x33};
2581 static const UChar toUnicode943sub[] = { 0x304b, 0x0061, 0x0062, 0x0063, 0x1a, 0x1a, 0x0032, 0x0033 };
2582 static const int32_t fromIBM943Offssub[] = { 0, 2, 3, 4, 5, 6, 7, 8 };
2583 /*checking illegal value for ibm-943 with substitute*/
2584 gInBufferSize = inputsize;
2585 gOutBufferSize = outputsize;
2586
2587 if(!testConvertToUnicode(sampleText, UPRV_LENGTHOF(sampleText),
2588 toUnicode943sub, UPRV_LENGTHOF(toUnicode943sub),"ibm-943",
2589 UCNV_TO_U_CALLBACK_SUBSTITUTE, fromIBM943Offssub, NULL, 0 ))
2590 log_err("ibm-943->u with subst did not match.\n");
2591 }
2592
2593 static void TestEBCDIC_STATEFUL_Sub(int32_t inputsize, int32_t outputsize)
2594 {
2595 /*EBCDIC_STATEFUL*/
2596 static const UChar ebcdic_inputTest[] = { 0x0061, 0x6d64, 0x0061, 0x00A2, 0x6d65, 0x0061 };
2597 static const uint8_t toIBM930[]= { 0x62, 0x0e, 0x5d, 0x63, 0x0f, 0x62, 0xb1, 0x0e, 0xfe, 0xfe, 0x0f, 0x62 };
2598 static const int32_t offset_930[]= { 0, 1, 1, 1, 2, 2, 3, 4, 4, 4, 5, 5 };
2599 /* s SO doubl SI sng s SO fe fe SI s */
2600
2601 /*EBCDIC_STATEFUL with subChar=3f*/
2602 static const uint8_t toIBM930_subvaried[]= { 0x62, 0x0e, 0x5d, 0x63, 0x0f, 0x62, 0xb1, 0x3f, 0x62 };
2603 static const int32_t offset_930_subvaried[]= { 0, 1, 1, 1, 2, 2, 3, 4, 5 };
2604 static const char mySubChar[]={ 0x3f};
2605
2606 gInBufferSize = inputsize;
2607 gOutBufferSize = outputsize;
2608
2609 if(!testConvertFromUnicode(ebcdic_inputTest, UPRV_LENGTHOF(ebcdic_inputTest),
2610 toIBM930, UPRV_LENGTHOF(toIBM930), "ibm-930",
2611 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offset_930, NULL, 0 ))
2612 log_err("u-> ibm-930(EBCDIC_STATEFUL) with subst did not match.\n");
2613
2614 if(!testConvertFromUnicode(ebcdic_inputTest, UPRV_LENGTHOF(ebcdic_inputTest),
2615 toIBM930_subvaried, UPRV_LENGTHOF(toIBM930_subvaried), "ibm-930",
2616 UCNV_FROM_U_CALLBACK_SUBSTITUTE, offset_930_subvaried, mySubChar, 1 ))
2617 log_err("u-> ibm-930(EBCDIC_STATEFUL) with subst(setSubChar=0x3f) did not match.\n");
2618 }
2619 #endif
2620
2621 UBool testConvertFromUnicode(const UChar *source, int sourceLen, const uint8_t *expect, int expectLen,
2622 const char *codepage, UConverterFromUCallback callback , const int32_t *expectOffsets,
2623 const char *mySubChar, int8_t len)
2624 {
2625
2626
2627 UErrorCode status = U_ZERO_ERROR;
2628 UConverter *conv = 0;
2629 char junkout[NEW_MAX_BUFFER]; /* FIX */
2630 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
2631 const UChar *src;
2632 char *end;
2633 char *targ;
2634 int32_t *offs;
2635 int i;
2636 int32_t realBufferSize;
2637 char *realBufferEnd;
2638 const UChar *realSourceEnd;
2639 const UChar *sourceLimit;
2640 UBool checkOffsets = TRUE;
2641 UBool doFlush;
2642 char junk[9999];
2643 char offset_str[9999];
2644 char *p;
2645 UConverterFromUCallback oldAction = NULL;
2646 const void* oldContext = NULL;
2647
2648
2649 for(i=0;i<NEW_MAX_BUFFER;i++)
2650 junkout[i] = (char)0xF0;
2651 for(i=0;i<NEW_MAX_BUFFER;i++)
2652 junokout[i] = 0xFF;
2653 setNuConvTestName(codepage, "FROM");
2654
2655 log_verbose("\nTesting========= %s FROM \n inputbuffer= %d outputbuffer= %d\n", codepage, gInBufferSize,
2656 gOutBufferSize);
2657
2658 conv = ucnv_open(codepage, &status);
2659 if(U_FAILURE(status))
2660 {
2661 log_data_err("Couldn't open converter %s\n",codepage);
2662 return TRUE;
2663 }
2664
2665 log_verbose("Converter opened..\n");
2666
2667 /*----setting the callback routine----*/
2668 ucnv_setFromUCallBack (conv, callback, NULL, &oldAction, &oldContext, &status);
2669 if (U_FAILURE(status))
2670 {
2671 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
2672 }
2673 /*------------------------*/
2674 /*setting the subChar*/
2675 if(mySubChar != NULL){
2676 ucnv_setSubstChars(conv, mySubChar, len, &status);
2677 if (U_FAILURE(status)) {
2678 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
2679 }
2680 }
2681 /*------------*/
2682
2683 src = source;
2684 targ = junkout;
2685 offs = junokout;
2686
2687 realBufferSize = UPRV_LENGTHOF(junkout);
2688 realBufferEnd = junkout + realBufferSize;
2689 realSourceEnd = source + sourceLen;
2690
2691 if ( gOutBufferSize != realBufferSize )
2692 checkOffsets = FALSE;
2693
2694 if( gInBufferSize != NEW_MAX_BUFFER )
2695 checkOffsets = FALSE;
2696
2697 do
2698 {
2699 end = nct_min(targ + gOutBufferSize, realBufferEnd);
2700 sourceLimit = nct_min(src + gInBufferSize, realSourceEnd);
2701
2702 doFlush = (UBool)(sourceLimit == realSourceEnd);
2703
2704 if(targ == realBufferEnd)
2705 {
2706 log_err("Error, overflowed the real buffer while about to call fromUnicode! targ=%08lx %s", targ, gNuConvTestName);
2707 return FALSE;
2708 }
2709 log_verbose("calling fromUnicode @ SOURCE:%08lx to %08lx TARGET: %08lx to %08lx, flush=%s\n", src,sourceLimit, targ,end, doFlush?"TRUE":"FALSE");
2710
2711
2712 status = U_ZERO_ERROR;
2713
2714 ucnv_fromUnicode (conv,
2715 (char **)&targ,
2716 (const char *)end,
2717 &src,
2718 sourceLimit,
2719 checkOffsets ? offs : NULL,
2720 doFlush, /* flush if we're at the end of the input data */
2721 &status);
2722 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && (sourceLimit < realSourceEnd)) );
2723
2724
2725 if(status==U_INVALID_CHAR_FOUND || status == U_ILLEGAL_CHAR_FOUND){
2726 UChar errChars[50]; /* should be sufficient */
2727 int8_t errLen = 50;
2728 UErrorCode err = U_ZERO_ERROR;
2729 const UChar* start= NULL;
2730 ucnv_getInvalidUChars(conv,errChars, &errLen, &err);
2731 if(U_FAILURE(err)){
2732 log_err("ucnv_getInvalidUChars failed with error : %s\n",u_errorName(err));
2733 }
2734 /* length of in invalid chars should be equal to returned length*/
2735 start = src - errLen;
2736 if(u_strncmp(errChars,start,errLen)!=0){
2737 log_err("ucnv_getInvalidUChars did not return the correct invalid chars for encoding %s \n", ucnv_getName(conv,&err));
2738 }
2739 }
2740 /* allow failure codes for the stop callback */
2741 if(U_FAILURE(status) &&
2742 (callback != UCNV_FROM_U_CALLBACK_STOP || (status != U_INVALID_CHAR_FOUND && status != U_ILLEGAL_CHAR_FOUND)))
2743 {
2744 log_err("Problem in fromUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
2745 return FALSE;
2746 }
2747
2748 log_verbose("\nConversion done [%d uchars in -> %d chars out]. \nResult :",
2749 sourceLen, targ-junkout);
2750 if(getTestOption(VERBOSITY_OPTION))
2751 {
2752
2753 junk[0] = 0;
2754 offset_str[0] = 0;
2755 for(p = junkout;p<targ;p++)
2756 {
2757 sprintf(junk + strlen(junk), "0x%02x, ", (0xFF) & (unsigned int)*p);
2758 sprintf(offset_str + strlen(offset_str), "0x%02x, ", (0xFF) & (unsigned int)junokout[p-junkout]);
2759 }
2760
2761 log_verbose(junk);
2762 printSeq(expect, expectLen);
2763 if ( checkOffsets )
2764 {
2765 log_verbose("\nOffsets:");
2766 log_verbose(offset_str);
2767 }
2768 log_verbose("\n");
2769 }
2770 ucnv_close(conv);
2771
2772
2773 if(expectLen != targ-junkout)
2774 {
2775 log_err("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
2776 log_verbose("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
2777 printSeqErr((const uint8_t *)junkout, (int32_t)(targ-junkout));
2778 printSeqErr(expect, expectLen);
2779 return FALSE;
2780 }
2781
2782 if (checkOffsets && (expectOffsets != 0) )
2783 {
2784 log_verbose("comparing %d offsets..\n", targ-junkout);
2785 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t) )){
2786 log_err("did not get the expected offsets while %s \n", gNuConvTestName);
2787 log_err("Got Output : ");
2788 printSeqErr((const uint8_t *)junkout, (int32_t)(targ-junkout));
2789 log_err("Got Offsets: ");
2790 for(p=junkout;p<targ;p++)
2791 log_err("%d,", junokout[p-junkout]);
2792 log_err("\n");
2793 log_err("Expected Offsets: ");
2794 for(i=0; i<(targ-junkout); i++)
2795 log_err("%d,", expectOffsets[i]);
2796 log_err("\n");
2797 return FALSE;
2798 }
2799 }
2800
2801 if(!memcmp(junkout, expect, expectLen))
2802 {
2803 log_verbose("String matches! %s\n", gNuConvTestName);
2804 return TRUE;
2805 }
2806 else
2807 {
2808 log_err("String does not match. %s\n", gNuConvTestName);
2809 log_err("source: ");
2810 printUSeqErr(source, sourceLen);
2811 log_err("Got: ");
2812 printSeqErr((const uint8_t *)junkout, expectLen);
2813 log_err("Expected: ");
2814 printSeqErr(expect, expectLen);
2815 return FALSE;
2816 }
2817 }
2818
2819 UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen,
2820 const char *codepage, UConverterToUCallback callback, const int32_t *expectOffsets,
2821 const char *mySubChar, int8_t len)
2822 {
2823 UErrorCode status = U_ZERO_ERROR;
2824 UConverter *conv = 0;
2825 UChar junkout[NEW_MAX_BUFFER]; /* FIX */
2826 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
2827 const char *src;
2828 const char *realSourceEnd;
2829 const char *srcLimit;
2830 UChar *targ;
2831 UChar *end;
2832 int32_t *offs;
2833 int i;
2834 UBool checkOffsets = TRUE;
2835 char junk[9999];
2836 char offset_str[9999];
2837 UChar *p;
2838 UConverterToUCallback oldAction = NULL;
2839 const void* oldContext = NULL;
2840
2841 int32_t realBufferSize;
2842 UChar *realBufferEnd;
2843
2844
2845 for(i=0;i<NEW_MAX_BUFFER;i++)
2846 junkout[i] = 0xFFFE;
2847
2848 for(i=0;i<NEW_MAX_BUFFER;i++)
2849 junokout[i] = -1;
2850
2851 setNuConvTestName(codepage, "TO");
2852
2853 log_verbose("\n========= %s\n", gNuConvTestName);
2854
2855 conv = ucnv_open(codepage, &status);
2856 if(U_FAILURE(status))
2857 {
2858 log_data_err("Couldn't open converter %s\n",gNuConvTestName);
2859 return TRUE;
2860 }
2861
2862 log_verbose("Converter opened..\n");
2863
2864 src = (const char *)source;
2865 targ = junkout;
2866 offs = junokout;
2867
2868 realBufferSize = UPRV_LENGTHOF(junkout);
2869 realBufferEnd = junkout + realBufferSize;
2870 realSourceEnd = src + sourcelen;
2871 /*----setting the callback routine----*/
2872 ucnv_setToUCallBack (conv, callback, NULL, &oldAction, &oldContext, &status);
2873 if (U_FAILURE(status))
2874 {
2875 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
2876 }
2877 /*-------------------------------------*/
2878 /*setting the subChar*/
2879 if(mySubChar != NULL){
2880 ucnv_setSubstChars(conv, mySubChar, len, &status);
2881 if (U_FAILURE(status)) {
2882 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
2883 }
2884 }
2885 /*------------*/
2886
2887
2888 if ( gOutBufferSize != realBufferSize )
2889 checkOffsets = FALSE;
2890
2891 if( gInBufferSize != NEW_MAX_BUFFER )
2892 checkOffsets = FALSE;
2893
2894 do
2895 {
2896 end = nct_min( targ + gOutBufferSize, realBufferEnd);
2897 srcLimit = nct_min(realSourceEnd, src + gInBufferSize);
2898
2899 if(targ == realBufferEnd)
2900 {
2901 log_err("Error, the end would overflow the real output buffer while about to call toUnicode! tarjey=%08lx %s",targ,gNuConvTestName);
2902 return FALSE;
2903 }
2904 log_verbose("calling toUnicode @ %08lx to %08lx\n", targ,end);
2905
2906
2907
2908 status = U_ZERO_ERROR;
2909
2910 ucnv_toUnicode (conv,
2911 &targ,
2912 end,
2913 (const char **)&src,
2914 (const char *)srcLimit,
2915 checkOffsets ? offs : NULL,
2916 (UBool)(srcLimit == realSourceEnd), /* flush if we're at the end of the source data */
2917 &status);
2918 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && (srcLimit < realSourceEnd)) ); /* while we just need another buffer */
2919
2920 if(status==U_INVALID_CHAR_FOUND || status == U_ILLEGAL_CHAR_FOUND){
2921 char errChars[50]; /* should be sufficient */
2922 int8_t errLen = 50;
2923 UErrorCode err = U_ZERO_ERROR;
2924 const char* start= NULL;
2925 ucnv_getInvalidChars(conv,errChars, &errLen, &err);
2926 if(U_FAILURE(err)){
2927 log_err("ucnv_getInvalidChars failed with error : %s\n",u_errorName(err));
2928 }
2929 /* length of in invalid chars should be equal to returned length*/
2930 start = src - errLen;
2931 if(uprv_strncmp(errChars,start,errLen)!=0){
2932 log_err("ucnv_getInvalidChars did not return the correct invalid chars for encoding %s \n", ucnv_getName(conv,&err));
2933 }
2934 }
2935 /* allow failure codes for the stop callback */
2936 if(U_FAILURE(status) &&
2937 (callback != UCNV_TO_U_CALLBACK_STOP || (status != U_INVALID_CHAR_FOUND && status != U_ILLEGAL_CHAR_FOUND && status != U_TRUNCATED_CHAR_FOUND)))
2938 {
2939 log_err("Problem doing toUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
2940 return FALSE;
2941 }
2942
2943 log_verbose("\nConversion done. %d bytes -> %d chars.\nResult :",
2944 sourcelen, targ-junkout);
2945 if(getTestOption(VERBOSITY_OPTION))
2946 {
2947
2948 junk[0] = 0;
2949 offset_str[0] = 0;
2950
2951 for(p = junkout;p<targ;p++)
2952 {
2953 sprintf(junk + strlen(junk), "0x%04x, ", (0xFFFF) & (unsigned int)*p);
2954 sprintf(offset_str + strlen(offset_str), "0x%04x, ", (0xFFFF) & (unsigned int)junokout[p-junkout]);
2955 }
2956
2957 log_verbose(junk);
2958 printUSeq(expect, expectlen);
2959 if ( checkOffsets )
2960 {
2961 log_verbose("\nOffsets:");
2962 log_verbose(offset_str);
2963 }
2964 log_verbose("\n");
2965 }
2966 ucnv_close(conv);
2967
2968 log_verbose("comparing %d uchars (%d bytes)..\n",expectlen,expectlen*2);
2969
2970 if (checkOffsets && (expectOffsets != 0))
2971 {
2972 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t)))
2973 {
2974 log_err("did not get the expected offsets while %s \n", gNuConvTestName);
2975 log_err("Got offsets: ");
2976 for(p=junkout;p<targ;p++)
2977 log_err(" %2d,", junokout[p-junkout]);
2978 log_err("\n");
2979 log_err("Expected offsets: ");
2980 for(i=0; i<(targ-junkout); i++)
2981 log_err(" %2d,", expectOffsets[i]);
2982 log_err("\n");
2983 log_err("Got output: ");
2984 for(i=0; i<(targ-junkout); i++)
2985 log_err("0x%04x,", junkout[i]);
2986 log_err("\n");
2987 log_err("From source: ");
2988 for(i=0; i<(src-(const char *)source); i++)
2989 log_err(" 0x%02x,", (unsigned char)source[i]);
2990 log_err("\n");
2991 }
2992 }
2993
2994 if(!memcmp(junkout, expect, expectlen*2))
2995 {
2996 log_verbose("Matches!\n");
2997 return TRUE;
2998 }
2999 else
3000 {
3001 log_err("String does not match. %s\n", gNuConvTestName);
3002 log_verbose("String does not match. %s\n", gNuConvTestName);
3003 log_err("Got: ");
3004 printUSeqErr(junkout, expectlen);
3005 log_err("Expected: ");
3006 printUSeqErr(expect, expectlen);
3007 log_err("\n");
3008 return FALSE;
3009 }
3010 }
3011
3012 UBool testConvertFromUnicodeWithContext(const UChar *source, int sourceLen, const uint8_t *expect, int expectLen,
3013 const char *codepage, UConverterFromUCallback callback , const int32_t *expectOffsets,
3014 const char *mySubChar, int8_t len, const void* context, UErrorCode expectedError)
3015 {
3016
3017
3018 UErrorCode status = U_ZERO_ERROR;
3019 UConverter *conv = 0;
3020 char junkout[NEW_MAX_BUFFER]; /* FIX */
3021 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
3022 const UChar *src;
3023 char *end;
3024 char *targ;
3025 int32_t *offs;
3026 int i;
3027 int32_t realBufferSize;
3028 char *realBufferEnd;
3029 const UChar *realSourceEnd;
3030 const UChar *sourceLimit;
3031 UBool checkOffsets = TRUE;
3032 UBool doFlush;
3033 char junk[9999];
3034 char offset_str[9999];
3035 char *p;
3036 UConverterFromUCallback oldAction = NULL;
3037 const void* oldContext = NULL;
3038
3039
3040 for(i=0;i<NEW_MAX_BUFFER;i++)
3041 junkout[i] = (char)0xF0;
3042 for(i=0;i<NEW_MAX_BUFFER;i++)
3043 junokout[i] = 0xFF;
3044 setNuConvTestName(codepage, "FROM");
3045
3046 log_verbose("\nTesting========= %s FROM \n inputbuffer= %d outputbuffer= %d\n", codepage, gInBufferSize,
3047 gOutBufferSize);
3048
3049 conv = ucnv_open(codepage, &status);
3050 if(U_FAILURE(status))
3051 {
3052 log_data_err("Couldn't open converter %s\n",codepage);
3053 return TRUE; /* Because the err has already been logged. */
3054 }
3055
3056 log_verbose("Converter opened..\n");
3057
3058 /*----setting the callback routine----*/
3059 ucnv_setFromUCallBack (conv, callback, context, &oldAction, &oldContext, &status);
3060 if (U_FAILURE(status))
3061 {
3062 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
3063 }
3064 /*------------------------*/
3065 /*setting the subChar*/
3066 if(mySubChar != NULL){
3067 ucnv_setSubstChars(conv, mySubChar, len, &status);
3068 if (U_FAILURE(status)) {
3069 log_err("FAILURE in setting substitution chars! %s\n", myErrorName(status));
3070 }
3071 }
3072 /*------------*/
3073
3074 src = source;
3075 targ = junkout;
3076 offs = junokout;
3077
3078 realBufferSize = UPRV_LENGTHOF(junkout);
3079 realBufferEnd = junkout + realBufferSize;
3080 realSourceEnd = source + sourceLen;
3081
3082 if ( gOutBufferSize != realBufferSize )
3083 checkOffsets = FALSE;
3084
3085 if( gInBufferSize != NEW_MAX_BUFFER )
3086 checkOffsets = FALSE;
3087
3088 do
3089 {
3090 end = nct_min(targ + gOutBufferSize, realBufferEnd);
3091 sourceLimit = nct_min(src + gInBufferSize, realSourceEnd);
3092
3093 doFlush = (UBool)(sourceLimit == realSourceEnd);
3094
3095 if(targ == realBufferEnd)
3096 {
3097 log_err("Error, overflowed the real buffer while about to call fromUnicode! targ=%08lx %s", targ, gNuConvTestName);
3098 return FALSE;
3099 }
3100 log_verbose("calling fromUnicode @ SOURCE:%08lx to %08lx TARGET: %08lx to %08lx, flush=%s\n", src,sourceLimit, targ,end, doFlush?"TRUE":"FALSE");
3101
3102
3103 status = U_ZERO_ERROR;
3104
3105 ucnv_fromUnicode (conv,
3106 (char **)&targ,
3107 (const char *)end,
3108 &src,
3109 sourceLimit,
3110 checkOffsets ? offs : NULL,
3111 doFlush, /* flush if we're at the end of the input data */
3112 &status);
3113 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && (sourceLimit < realSourceEnd)) );
3114
3115 /* allow failure codes for the stop callback */
3116 if(U_FAILURE(status) && status != expectedError)
3117 {
3118 log_err("Problem in fromUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
3119 return FALSE;
3120 }
3121
3122 log_verbose("\nConversion done [%d uchars in -> %d chars out]. \nResult :",
3123 sourceLen, targ-junkout);
3124 if(getTestOption(VERBOSITY_OPTION))
3125 {
3126
3127 junk[0] = 0;
3128 offset_str[0] = 0;
3129 for(p = junkout;p<targ;p++)
3130 {
3131 sprintf(junk + strlen(junk), "0x%02x, ", (0xFF) & (unsigned int)*p);
3132 sprintf(offset_str + strlen(offset_str), "0x%02x, ", (0xFF) & (unsigned int)junokout[p-junkout]);
3133 }
3134
3135 log_verbose(junk);
3136 printSeq(expect, expectLen);
3137 if ( checkOffsets )
3138 {
3139 log_verbose("\nOffsets:");
3140 log_verbose(offset_str);
3141 }
3142 log_verbose("\n");
3143 }
3144 ucnv_close(conv);
3145
3146
3147 if(expectLen != targ-junkout)
3148 {
3149 log_err("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
3150 log_verbose("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
3151 printSeqErr((const uint8_t *)junkout, (int32_t)(targ-junkout));
3152 printSeqErr(expect, expectLen);
3153 return FALSE;
3154 }
3155
3156 if (checkOffsets && (expectOffsets != 0) )
3157 {
3158 log_verbose("comparing %d offsets..\n", targ-junkout);
3159 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t) )){
3160 log_err("did not get the expected offsets while %s \n", gNuConvTestName);
3161 log_err("Got Output : ");
3162 printSeqErr((const uint8_t *)junkout, (int32_t)(targ-junkout));
3163 log_err("Got Offsets: ");
3164 for(p=junkout;p<targ;p++)
3165 log_err("%d,", junokout[p-junkout]);
3166 log_err("\n");
3167 log_err("Expected Offsets: ");
3168 for(i=0; i<(targ-junkout); i++)
3169 log_err("%d,", expectOffsets[i]);
3170 log_err("\n");
3171 return FALSE;
3172 }
3173 }
3174
3175 if(!memcmp(junkout, expect, expectLen))
3176 {
3177 log_verbose("String matches! %s\n", gNuConvTestName);
3178 return TRUE;
3179 }
3180 else
3181 {
3182 log_err("String does not match. %s\n", gNuConvTestName);
3183 log_err("source: ");
3184 printUSeqErr(source, sourceLen);
3185 log_err("Got: ");
3186 printSeqErr((const uint8_t *)junkout, expectLen);
3187 log_err("Expected: ");
3188 printSeqErr(expect, expectLen);
3189 return FALSE;
3190 }
3191 }
3192 UBool testConvertToUnicodeWithContext( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen,
3193 const char *codepage, UConverterToUCallback callback, const int32_t *expectOffsets,
3194 const char *mySubChar, int8_t len, const void* context, UErrorCode expectedError)
3195 {
3196 UErrorCode status = U_ZERO_ERROR;
3197 UConverter *conv = 0;
3198 UChar junkout[NEW_MAX_BUFFER]; /* FIX */
3199 int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
3200 const char *src;
3201 const char *realSourceEnd;
3202 const char *srcLimit;
3203 UChar *targ;
3204 UChar *end;
3205 int32_t *offs;
3206 int i;
3207 UBool checkOffsets = TRUE;
3208 char junk[9999];
3209 char offset_str[9999];
3210 UChar *p;
3211 UConverterToUCallback oldAction = NULL;
3212 const void* oldContext = NULL;
3213
3214 int32_t realBufferSize;
3215 UChar *realBufferEnd;
3216
3217
3218 for(i=0;i<NEW_MAX_BUFFER;i++)
3219 junkout[i] = 0xFFFE;
3220
3221 for(i=0;i<NEW_MAX_BUFFER;i++)
3222 junokout[i] = -1;
3223
3224 setNuConvTestName(codepage, "TO");
3225
3226 log_verbose("\n========= %s\n", gNuConvTestName);
3227
3228 conv = ucnv_open(codepage, &status);
3229 if(U_FAILURE(status))
3230 {
3231 log_data_err("Couldn't open converter %s\n",gNuConvTestName);
3232 return TRUE;
3233 }
3234
3235 log_verbose("Converter opened..\n");
3236
3237 src = (const char *)source;
3238 targ = junkout;
3239 offs = junokout;
3240
3241 realBufferSize = UPRV_LENGTHOF(junkout);
3242 realBufferEnd = junkout + realBufferSize;
3243 realSourceEnd = src + sourcelen;
3244 /*----setting the callback routine----*/
3245 ucnv_setToUCallBack (conv, callback, context, &oldAction, &oldContext, &status);
3246 if (U_FAILURE(status))
3247 {
3248 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
3249 }
3250 /*-------------------------------------*/
3251 /*setting the subChar*/
3252 if(mySubChar != NULL){
3253 ucnv_setSubstChars(conv, mySubChar, len, &status);
3254 if (U_FAILURE(status)) {
3255 log_err("FAILURE in setting the callback Function! %s\n", myErrorName(status));
3256 }
3257 }
3258 /*------------*/
3259
3260
3261 if ( gOutBufferSize != realBufferSize )
3262 checkOffsets = FALSE;
3263
3264 if( gInBufferSize != NEW_MAX_BUFFER )
3265 checkOffsets = FALSE;
3266
3267 do
3268 {
3269 end = nct_min( targ + gOutBufferSize, realBufferEnd);
3270 srcLimit = nct_min(realSourceEnd, src + gInBufferSize);
3271
3272 if(targ == realBufferEnd)
3273 {
3274 log_err("Error, the end would overflow the real output buffer while about to call toUnicode! tarjey=%08lx %s",targ,gNuConvTestName);
3275 return FALSE;
3276 }
3277 log_verbose("calling toUnicode @ %08lx to %08lx\n", targ,end);
3278
3279
3280
3281 status = U_ZERO_ERROR;
3282
3283 ucnv_toUnicode (conv,
3284 &targ,
3285 end,
3286 (const char **)&src,
3287 (const char *)srcLimit,
3288 checkOffsets ? offs : NULL,
3289 (UBool)(srcLimit == realSourceEnd), /* flush if we're at the end of the source data */
3290 &status);
3291 } while ( (status == U_BUFFER_OVERFLOW_ERROR) || (U_SUCCESS(status) && (srcLimit < realSourceEnd)) ); /* while we just need another buffer */
3292
3293 /* allow failure codes for the stop callback */
3294 if(U_FAILURE(status) && status!=expectedError)
3295 {
3296 log_err("Problem doing toUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
3297 return FALSE;
3298 }
3299
3300 log_verbose("\nConversion done. %d bytes -> %d chars.\nResult :",
3301 sourcelen, targ-junkout);
3302 if(getTestOption(VERBOSITY_OPTION))
3303 {
3304
3305 junk[0] = 0;
3306 offset_str[0] = 0;
3307
3308 for(p = junkout;p<targ;p++)
3309 {
3310 sprintf(junk + strlen(junk), "0x%04x, ", (0xFFFF) & (unsigned int)*p);
3311 sprintf(offset_str + strlen(offset_str), "0x%04x, ", (0xFFFF) & (unsigned int)junokout[p-junkout]);
3312 }
3313
3314 log_verbose(junk);
3315 printUSeq(expect, expectlen);
3316 if ( checkOffsets )
3317 {
3318 log_verbose("\nOffsets:");
3319 log_verbose(offset_str);
3320 }
3321 log_verbose("\n");
3322 }
3323 ucnv_close(conv);
3324
3325 log_verbose("comparing %d uchars (%d bytes)..\n",expectlen,expectlen*2);
3326
3327 if (checkOffsets && (expectOffsets != 0))
3328 {
3329 if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t)))
3330 {
3331 log_err("did not get the expected offsets while %s \n", gNuConvTestName);
3332 log_err("Got offsets: ");
3333 for(p=junkout;p<targ;p++)
3334 log_err(" %2d,", junokout[p-junkout]);
3335 log_err("\n");
3336 log_err("Expected offsets: ");
3337 for(i=0; i<(targ-junkout); i++)
3338 log_err(" %2d,", expectOffsets[i]);
3339 log_err("\n");
3340 log_err("Got output: ");
3341 for(i=0; i<(targ-junkout); i++)
3342 log_err("0x%04x,", junkout[i]);
3343 log_err("\n");
3344 log_err("From source: ");
3345 for(i=0; i<(src-(const char *)source); i++)
3346 log_err(" 0x%02x,", (unsigned char)source[i]);
3347 log_err("\n");
3348 }
3349 }
3350
3351 if(!memcmp(junkout, expect, expectlen*2))
3352 {
3353 log_verbose("Matches!\n");
3354 return TRUE;
3355 }
3356 else
3357 {
3358 log_err("String does not match. %s\n", gNuConvTestName);
3359 log_verbose("String does not match. %s\n", gNuConvTestName);
3360 log_err("Got: ");
3361 printUSeqErr(junkout, expectlen);
3362 log_err("Expected: ");
3363 printUSeqErr(expect, expectlen);
3364 log_err("\n");
3365 return FALSE;
3366 }
3367 }
3368
3369 static void TestCallBackFailure(void) {
3370 UErrorCode status = U_USELESS_COLLATOR_ERROR;
3371 ucnv_cbFromUWriteBytes(NULL, NULL, -1, -1, &status);
3372 if (status != U_USELESS_COLLATOR_ERROR) {
3373 log_err("Error: ucnv_cbFromUWriteBytes did not react correctly to a bad UErrorCode\n");
3374 }
3375 ucnv_cbFromUWriteUChars(NULL, NULL, NULL, -1, &status);
3376 if (status != U_USELESS_COLLATOR_ERROR) {
3377 log_err("Error: ucnv_cbFromUWriteUChars did not react correctly to a bad UErrorCode\n");
3378 }
3379 ucnv_cbFromUWriteSub(NULL, -1, &status);
3380 if (status != U_USELESS_COLLATOR_ERROR) {
3381 log_err("Error: ucnv_cbFromUWriteSub did not react correctly to a bad UErrorCode\n");
3382 }
3383 ucnv_cbToUWriteUChars(NULL, NULL, -1, -1, &status);
3384 if (status != U_USELESS_COLLATOR_ERROR) {
3385 log_err("Error: ucnv_cbToUWriteUChars did not react correctly to a bad UErrorCode\n");
3386 }
3387 }
mirror of ICU