1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "convert_test.h"
16
17 #include <cstdio>
18 #include <gtest/gtest.h>
19 #include <map>
20 #include <vector>
21 #include <unistd.h>
22 #include "unicode/utypes.h"
23 #include "unicode/ucnv.h"
24 #include "unicode/ustring.h"
25 #include "unicode/uchar.h"
26 #include "unicode/uloc.h"
27 #include "unicode/unistr.h"
28 #include "ohos/init_data.h"
29
30 using namespace OHOS::Global::I18n;
31 using testing::ext::TestSize;
32 using namespace std;
33 using namespace testing;
34
35 namespace OHOS {
36 namespace Global {
37 namespace I18n {
38 class ConvertTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44
45 static std::map<std::string, std::vector<char>> source1;
46 static std::map<std::string, std::vector<char>> source2;
47 };
48
49 /* "abc中國臺灣" */
50 std::map<std::string, std::vector<char>> ConvertTest::source1 = {
51 { "UTF-8", { 0x61, 0x62, 0x63, 0xE4, 0xB8, 0xAD, 0xE5, 0x9C, 0x8B, 0xE8, 0x87, 0xBA, 0xE7, 0x81, 0xA3 } },
52 { "UTF-7", { 0x61, 0x62, 0x63, 0x2B, 0x54, 0x69, 0x31, 0x58, 0x43, 0x34, 0x48, 0x36, 0x63, 0x47, 0x4D, 0x2D } },
53 { "UTF-16", { 0xFF, 0xFE, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x2D, 0x4E, 0x0B, 0x57, 0xFA, 0x81, 0x63, 0x70 } },
54 { "UTF-16BE", { 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x4E, 0x2D, 0x57, 0x0B, 0x81, 0xFA, 0x70, 0x63 } },
55 { "UTF-16LE", { 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x2D, 0x4E, 0x0B, 0x57, 0xFA, 0x81, 0x63, 0x70 } },
56 { "UTF-32", { 0xFF, 0xFE, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00,
57 0x62, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00,
58 0x2D, 0x4E, 0x00, 0x00, 0x0B, 0x57, 0x00, 0x00,
59 0xFA, 0x81, 0x00, 0x00, 0x63, 0x70, 0x00, 0x00 } },
60 { "UTF-32BE", { 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x62, 0x00,
61 0x00, 0x00, 0x63, 0x00, 0x00, 0x4E, 0x2D, 0x00, 0x00,
62 0x57, 0x0B, 0x00, 0x00, 0x81, 0xFA, 0x00, 0x00, 0x70, 0x63 } },
63 { "UTF-32LE", { 0x61, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x63,
64 0x00, 0x00, 0x00, 0x2D, 0x4E, 0x00, 0x00, 0x0B, 0x57,
65 0x00, 0x00, 0xFA, 0x81, 0x00, 0x00, 0x63, 0x70, 0x00, 0x00 } },
66 { "GBK", { 0x61, 0x62, 0x63, 0xD6, 0xD0, 0x87, 0xF8, 0xC5, 0x5F, 0x9E, 0xB3 } },
67 { "BIG5", { 0x61, 0x62, 0x63, 0xA4, 0xA4, 0xB0, 0xEA, 0xBB, 0x4F, 0xC6, 0x57 } },
68 };
69
70 /* "中aرདЧüん국" */
71 std::map<std::string, std::vector<char>> ConvertTest::source2 = {
72 { "UTF-8", { 0xE4, 0xB8, 0xAD, 0x61, 0xD8, 0xB1, 0xE0, 0xBD, 0x91, 0xD0,
73 0xA7, 0xC3, 0xBC, 0xE3, 0x82, 0x93, 0xEA, 0xB5, 0xAD } },
74 { "UTF-7", { 0x2B, 0x54, 0x69, 0x30, 0x2D, 0x61, 0x2B, 0x42, 0x6A, 0x45, 0x50, 0x55,
75 0x51, 0x51, 0x6E, 0x41, 0x50, 0x77, 0x77, 0x6B, 0x36, 0x31, 0x74, 0x2D } },
76 { "UTF-16", { 0xFF, 0xFE, 0x2D, 0x4E, 0x61, 0x00, 0x31, 0x06, 0x51,
77 0x0F, 0x27, 0x04, 0xFC, 0x00, 0x93, 0x30, 0x6D, 0xAD } },
78 { "UTF-16BE", { 0x4E, 0x2D, 0x00, 0x61, 0x06, 0x31, 0x0F, 0x51,
79 0x04, 0x27, 0x00, 0xFC, 0x30, 0x93, 0xAD, 0x6D } },
80 { "UTF-16LE", { 0x2D, 0x4E, 0x61, 0x00, 0x31, 0x06, 0x51, 0x0F,
81 0x27, 0x04, 0xFC, 0x00, 0x93, 0x30, 0x6D, 0xAD } },
82 { "UTF-32", { 0xFF, 0xFE, 0x00, 0x00, 0x2D, 0x4E, 0x00, 0x00, 0x61,
83 0x00, 0x00, 0x00, 0x31, 0x06, 0x00, 0x00, 0x51, 0x0F,
84 0x00, 0x00, 0x27, 0x04, 0x00, 0x00, 0xFC, 0x00, 0x00,
85 0x00, 0x93, 0x30, 0x00, 0x00, 0x6D, 0xAD, 0x00, 0x00 } },
86 { "UTF-32BE", { 0x00, 0x00, 0x4E, 0x2D, 0x00, 0x00, 0x00, 0x61,
87 0x00, 0x00, 0x06, 0x31, 0x00, 0x00, 0x0F, 0x51,
88 0x00, 0x00, 0x04, 0x27, 0x00, 0x00, 0x00, 0xFC,
89 0x00, 0x00, 0x30, 0x93, 0x00, 0x00, 0xAD, 0x6D } },
90 { "UTF-32LE", { 0x2D, 0x4E, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00,
91 0x31, 0x06, 0x00, 0x00, 0x51, 0x0F, 0x00, 0x00,
92 0x27, 0x04, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00,
93 0x93, 0x30, 0x00, 0x00, 0x6D, 0xAD, 0x00, 0x00 } },
94 };
95
SetUpTestCase(void)96 void ConvertTest::SetUpTestCase(void)
97 {
98 SetHwIcuDirectory();
99 }
100
TearDownTestCase(void)101 void ConvertTest::TearDownTestCase(void)
102 {
103 }
104
SetUp(void)105 void ConvertTest::SetUp(void)
106 {}
107
TearDown(void)108 void ConvertTest::TearDown(void)
109 {}
110
111 /**
112 * @tc.name: ConvertTest0001
113 * @tc.desc: Test ucnv_convert
114 * @tc.type: FUNC
115 */
116 HWTEST_F(ConvertTest, ConvertTest0001, TestSize.Level1)
117 {
118 /* from UTF-8 to others */
119 for (auto iter = ConvertTest::source1.begin(); iter != ConvertTest::source1.end(); ++iter) {
120 if (iter->first == "UTF-8") {
121 continue;
122 }
123 UErrorCode err = U_ZERO_ERROR;
124 char target[100];
125 int32_t size = ucnv_convert(iter->first.c_str(), /* out */
126 "UTF-8", /* in */
127 target,
128 sizeof(target),
129 &ConvertTest::source1["UTF-8"][0],
130 ConvertTest::source1["UTF-8"].size(),
131 &err);
132 ASSERT_TRUE(U_SUCCESS(err));
133 EXPECT_EQ(size, iter->second.size());
134 for (int32_t i = 0; i < size; ++i) {
135 EXPECT_EQ(target[i], iter->second[i]);
136 }
137 }
138
139 /* from others to UTF-8 */
140 for (auto iter = ConvertTest::source1.begin(); iter != ConvertTest::source1.end(); ++iter) {
141 if (iter->first == "UTF-8") {
142 continue;
143 }
144 UErrorCode err = U_ZERO_ERROR;
145 char target[100];
146 int32_t size = ucnv_convert("UTF-8", /* out */
147 iter->first.c_str(), /* in */
148 target,
149 sizeof(target),
150 &(iter->second)[0],
151 iter->second.size(),
152 &err);
153 ASSERT_TRUE(U_SUCCESS(err));
154 EXPECT_EQ(size, ConvertTest::source1["UTF-8"].size());
155 for (int32_t i = 0; i < size; ++i) {
156 EXPECT_EQ(target[i], ConvertTest::source1["UTF-8"][i]);
157 }
158 }
159 }
160
161 /**
162 * @tc.name: ConvertTest0002
163 * @tc.desc: Test ucnv_toUChars and ucnv_fromUChars
164 * @tc.type: FUNC
165 */
166 HWTEST_F(ConvertTest, ConvertTest0002, TestSize.Level1)
167 {
168 for (auto iter = ConvertTest::source1.begin(); iter != ConvertTest::source1.end(); ++iter) {
169 if (iter->first == "UTF-8") {
170 continue;
171 }
172 UErrorCode status = U_ZERO_ERROR;
173 UConverter *convUTF8 = ucnv_open("UTF-8", &status);
174 ASSERT_TRUE(U_SUCCESS(status));
175 UConverter *convOthers = ucnv_open(iter->first.c_str(), &status);
176 ASSERT_TRUE(U_SUCCESS(status));
177 UChar ucharOther[100];
178 char targetOther[100];
179 // from UTF-8 to UChars
180 int32_t ucharLen = ucnv_toUChars(convUTF8, ucharOther, 100,
181 &ConvertTest::source1["UTF-8"][0], ConvertTest::source1["UTF-8"].size(), &status);
182 ASSERT_TRUE(U_SUCCESS(status));
183
184 // from UChars to other encoding
185 int32_t otherLen = ucnv_fromUChars(convOthers, targetOther, 100, ucharOther, ucharLen, &status);
186 ASSERT_TRUE(U_SUCCESS(status));
187
188 EXPECT_EQ(otherLen, iter->second.size());
189 for (int32_t i = 0; i < otherLen; ++i) {
190 EXPECT_EQ(targetOther[i], iter->second[i]);
191 }
192
193 UChar ucharUTF8[100];
194 char targetUTF8[100];
195 // from other encoding to UChars
196 int32_t ucharLen2 = ucnv_toUChars(convOthers, ucharUTF8, 100,
197 &(iter->second)[0], iter->second.size(), &status);
198 ASSERT_TRUE(U_SUCCESS(status));
199
200 EXPECT_EQ(ucharLen, ucharLen2);
201 for (int32_t i = 0; i < ucharLen; ++i) {
202 EXPECT_EQ(ucharOther[i], ucharUTF8[i]);
203 }
204
205 // from UChars to UTF-8
206 int32_t utf8Len = ucnv_fromUChars(convUTF8, targetUTF8, 100, ucharUTF8, ucharLen2, &status);
207 ASSERT_TRUE(U_SUCCESS(status));
208
209 EXPECT_EQ(utf8Len, ConvertTest::source1["UTF-8"].size());
210 for (int32_t i = 0; i < utf8Len; ++i) {
211 EXPECT_EQ(targetUTF8[i], ConvertTest::source1["UTF-8"][i]);
212 }
213
214 ucnv_close(convUTF8);
215 ucnv_close(convOthers);
216 }
217 }
218
219 /**
220 * @tc.name: ConvertTest0003
221 * @tc.desc: Test ucnv_convert
222 * @tc.type: FUNC
223 */
224 HWTEST_F(ConvertTest, ConvertTest0003, TestSize.Level1)
225 {
226 /* from UTF-8 to others */
227 for (auto iter = ConvertTest::source2.begin(); iter != ConvertTest::source2.end(); ++iter) {
228 if (iter->first == "UTF-8") {
229 continue;
230 }
231 UErrorCode err = U_ZERO_ERROR;
232 char target[100];
233 int32_t size = ucnv_convert(iter->first.c_str(), /* out */
234 "UTF-8", /* in */
235 target,
236 sizeof(target),
237 &ConvertTest::source2["UTF-8"][0],
238 ConvertTest::source2["UTF-8"].size(),
239 &err);
240 ASSERT_TRUE(U_SUCCESS(err));
241 EXPECT_EQ(size, iter->second.size());
242 for (int32_t i = 0; i < size; ++i) {
243 EXPECT_EQ(target[i], iter->second[i]);
244 }
245 }
246
247 /* from others to UTF-8 */
248 for (auto iter = ConvertTest::source2.begin(); iter != ConvertTest::source2.end(); ++iter) {
249 if (iter->first == "UTF-8") {
250 continue;
251 }
252 UErrorCode err = U_ZERO_ERROR;
253 char target[100];
254 int32_t size = ucnv_convert("UTF-8", /* out */
255 iter->first.c_str(), /* in */
256 target,
257 sizeof(target),
258 &(iter->second)[0],
259 iter->second.size(),
260 &err);
261 ASSERT_TRUE(U_SUCCESS(err));
262 EXPECT_EQ(size, ConvertTest::source2["UTF-8"].size());
263 for (int32_t i = 0; i < size; ++i) {
264 EXPECT_EQ(target[i], ConvertTest::source2["UTF-8"][i]);
265 }
266 }
267 }
268
269 /**
270 * @tc.name: ConvertTest0004
271 * @tc.desc: Test ucnv_toUChars and ucnv_fromUChars
272 * @tc.type: FUNC
273 */
274 HWTEST_F(ConvertTest, ConvertTest0004, TestSize.Level1)
275 {
276 for (auto iter = ConvertTest::source2.begin(); iter != ConvertTest::source2.end(); ++iter) {
277 if (iter->first == "UTF-8") {
278 continue;
279 }
280 UErrorCode status = U_ZERO_ERROR;
281 UConverter *convUTF8 = ucnv_open("UTF-8", &status);
282 ASSERT_TRUE(U_SUCCESS(status));
283 UConverter *convOthers = ucnv_open(iter->first.c_str(), &status);
284 ASSERT_TRUE(U_SUCCESS(status));
285 UChar ucharOther[100];
286 char targetOther[100];
287 // from UTF-8 to UChars
288 int32_t ucharLen = ucnv_toUChars(convUTF8, ucharOther, 100,
289 &ConvertTest::source2["UTF-8"][0], ConvertTest::source2["UTF-8"].size(), &status);
290 ASSERT_TRUE(U_SUCCESS(status));
291
292 // from UChars to other encoding
293 int32_t otherLen = ucnv_fromUChars(convOthers, targetOther, 100, ucharOther, ucharLen, &status);
294 ASSERT_TRUE(U_SUCCESS(status));
295
296 EXPECT_EQ(otherLen, iter->second.size());
297 for (int32_t i = 0; i < otherLen; ++i) {
298 EXPECT_EQ(targetOther[i], iter->second[i]);
299 }
300
301 UChar ucharUTF8[100];
302 char targetUTF8[100];
303 // from other encoding to UChars
304 int32_t ucharLen2 = ucnv_toUChars(convOthers, ucharUTF8, 100,
305 &(iter->second)[0], iter->second.size(), &status);
306 ASSERT_TRUE(U_SUCCESS(status));
307
308 EXPECT_EQ(ucharLen, ucharLen2);
309 for (int32_t i = 0; i < ucharLen; ++i) {
310 EXPECT_EQ(ucharOther[i], ucharUTF8[i]);
311 }
312
313 // from UChars to UTF-8
314 int32_t utf8Len = ucnv_fromUChars(convUTF8, targetUTF8, 100, ucharUTF8, ucharLen2, &status);
315 ASSERT_TRUE(U_SUCCESS(status));
316
317 EXPECT_EQ(utf8Len, ConvertTest::source2["UTF-8"].size());
318 for (int32_t i = 0; i < utf8Len; ++i) {
319 EXPECT_EQ(targetUTF8[i], ConvertTest::source2["UTF-8"][i]);
320 }
321
322 ucnv_close(convUTF8);
323 ucnv_close(convOthers);
324 }
325 }
326
327 /**
328 * @tc.name: ConvertTest0005
329 * @tc.desc: Test ucnv_setFromUCallBack UCNV_FROM_U_CALLBACK_STOP
330 * @tc.type: FUNC
331 */
332 HWTEST_F(ConvertTest, ConvertTest0005, TestSize.Level1)
333 {
334 /* "中a" */
335 char sourceGBK[] = { 0xD6, 0xD0, 0x61 };
336 UErrorCode status = U_ZERO_ERROR;
337 UConverter *convUTF8 = ucnv_open("UTF-8", &status);
338 ASSERT_TRUE(U_SUCCESS(status));
339 UConverter *convGBK = ucnv_open("GBK", &status);
340 ASSERT_TRUE(U_SUCCESS(status));
341 ucnv_setFromUCallBack(convGBK, UCNV_FROM_U_CALLBACK_STOP, nullptr, nullptr, nullptr, &status);
342 UChar ucharOther[100];
343 char targetOther[100];
344 // from UTF-8 to UChars
345 int32_t ucharLen = ucnv_toUChars(convUTF8, ucharOther, 100,
346 &ConvertTest::source2["UTF-8"][0], ConvertTest::source2["UTF-8"].size(), &status);
347 ASSERT_TRUE(U_SUCCESS(status));
348
349 // from UChars to other encoding
350 int32_t otherLen = ucnv_fromUChars(convGBK, targetOther, 100, ucharOther, ucharLen, &status);
351 EXPECT_EQ(status, U_INVALID_CHAR_FOUND);
352
353 EXPECT_EQ(otherLen, sizeof(sourceGBK));
354 for (int32_t i = 0; i < otherLen; ++i) {
355 EXPECT_EQ(targetOther[i], sourceGBK[i]);
356 }
357
358 ucnv_close(convUTF8);
359 ucnv_close(convGBK);
360 }
361
362 /**
363 * @tc.name: ConvertTest0006
364 * @tc.desc: Test ucnv_setFromUCallBack UCNV_FROM_U_CALLBACK_SKIP
365 * @tc.type: FUNC
366 */
367 HWTEST_F(ConvertTest, ConvertTest0006, TestSize.Level1)
368 {
369 /* "中aЧüん" */
370 char sourceGBK[] = { 0xD6, 0xD0, 0x61, 0xA7, 0xB9, 0xA8, 0xB9, 0xA4, 0xF3 };
371 UErrorCode status = U_ZERO_ERROR;
372 UConverter *convUTF8 = ucnv_open("UTF-8", &status);
373 ASSERT_TRUE(U_SUCCESS(status));
374 UConverter *convGBK = ucnv_open("GBK", &status);
375 ASSERT_TRUE(U_SUCCESS(status));
376 ucnv_setFromUCallBack(convGBK, UCNV_FROM_U_CALLBACK_SKIP, nullptr, nullptr, nullptr, &status);
377 UChar ucharOther[100];
378 char targetOther[100];
379 // from UTF-8 to UChars
380 int32_t ucharLen = ucnv_toUChars(convUTF8, ucharOther, 100,
381 &ConvertTest::source2["UTF-8"][0], ConvertTest::source2["UTF-8"].size(), &status);
382 ASSERT_TRUE(U_SUCCESS(status));
383
384 // from UChars to other encoding
385 int32_t otherLen = ucnv_fromUChars(convGBK, targetOther, 100, ucharOther, ucharLen, &status);
386 ASSERT_TRUE(U_SUCCESS(status));
387
388 EXPECT_EQ(otherLen, sizeof(sourceGBK));
389 for (int32_t i = 0; i < otherLen; ++i) {
390 EXPECT_EQ(targetOther[i], sourceGBK[i]);
391 }
392
393 ucnv_close(convUTF8);
394 ucnv_close(convGBK);
395 }
396
397 /**
398 * @tc.name: ConvertTest0007
399 * @tc.desc: Test ucnv_setFromUCallBack UCNV_FROM_U_CALLBACK_ESCAPE
400 * @tc.type: FUNC
401 */
402 HWTEST_F(ConvertTest, ConvertTest0007, TestSize.Level1)
403 {
404 /* "中a\u0631\u0F51Чüん\uAD6D" */
405 char sourceGBK[] = { 0xD6, 0xD0, 0x61, 0x5C, 0x75, 0x30, 0x36, 0x33, 0x31, 0x5C, 0x75, 0x30, 0x46,
406 0x35, 0x31, 0xA7, 0xB9, 0xA8, 0xB9, 0xA4, 0xF3, 0x5C, 0x75, 0x41, 0x44, 0x36, 0x44};
407 UErrorCode status = U_ZERO_ERROR;
408 UConverter *convUTF8 = ucnv_open("UTF-8", &status);
409 ASSERT_TRUE(U_SUCCESS(status));
410 UConverter *convGBK = ucnv_open("GBK", &status);
411 ASSERT_TRUE(U_SUCCESS(status));
412 /* UCNV_ESCAPE_ICU UCNV_ESCAPE_JAVA UCNV_ESCAPE_C UCNV_ESCAPE_XML_DEC UCNV_ESCAPE_XML_HEX */
413 ucnv_setFromUCallBack(convGBK, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_C, nullptr, nullptr, &status);
414 UChar ucharOther[100];
415 char targetOther[100];
416 // from UTF-8 to UChars
417 int32_t ucharLen = ucnv_toUChars(convUTF8, ucharOther, 100,
418 &ConvertTest::source2["UTF-8"][0], ConvertTest::source2["UTF-8"].size(), &status);
419 ASSERT_TRUE(U_SUCCESS(status));
420
421 // from UChars to other encoding
422 int32_t otherLen = ucnv_fromUChars(convGBK, targetOther, 100, ucharOther, ucharLen, &status);
423 ASSERT_TRUE(U_SUCCESS(status));
424
425 EXPECT_EQ(otherLen, sizeof(sourceGBK));
426 for (int32_t i = 0; i < otherLen; ++i) {
427 EXPECT_EQ(targetOther[i], sourceGBK[i]);
428 }
429
430 ucnv_close(convUTF8);
431 ucnv_close(convGBK);
432 }
433
434 /**
435 * @tc.name: ConvertTest0008
436 * @tc.desc: Test ucnv_setToUCallBack UCNV_TO_U_CALLBACK_STOP
437 * @tc.type: FUNC
438 */
439 HWTEST_F(ConvertTest, ConvertTest0008, TestSize.Level1)
440 {
441 /* "丂?疎" */
442 char sourceGBK[] = { 0x81, 0x40, 0x81, 0x7F, 0xAF, 0x45 };
443 /* "丂" */
444 UChar unicode[] = { 0x4E02 };
445 UErrorCode status = U_ZERO_ERROR;
446 UConverter *convGBK = ucnv_open("GBK", &status);
447 ASSERT_TRUE(U_SUCCESS(status));
448 ucnv_setToUCallBack(convGBK, UCNV_TO_U_CALLBACK_STOP, nullptr, nullptr, nullptr, &status);
449 UChar ucharOther[100];
450 // from GBK to UNICODE
451 int32_t ucharLen = ucnv_toUChars(convGBK, ucharOther, 100, sourceGBK, sizeof(sourceGBK), &status);
452 EXPECT_EQ(status, U_ILLEGAL_CHAR_FOUND);
453
454 EXPECT_EQ(ucharLen, sizeof(unicode) / sizeof(UChar));
455 for (int32_t i = 0; i < ucharLen; ++i) {
456 EXPECT_EQ(ucharOther[i], unicode[i]);
457 }
458
459 ucnv_close(convGBK);
460 }
461
462 /**
463 * @tc.name: ConvertTest0009
464 * @tc.desc: Test ucnv_setToUCallBack UCNV_TO_U_CALLBACK_SKIP
465 * @tc.type: FUNC
466 */
467 HWTEST_F(ConvertTest, ConvertTest0009, TestSize.Level1)
468 {
469 /* "丂?疎" */
470 char sourceGBK[] = { 0x81, 0x40, 0x81, 0x7F, 0xAF, 0x45 };
471 /* "丂疎" */
472 UChar unicode[] = { 0x4E02, 0x007F, 0x758E };
473 UErrorCode status = U_ZERO_ERROR;
474 UConverter *convGBK = ucnv_open("GBK", &status);
475 ASSERT_TRUE(U_SUCCESS(status));
476 ucnv_setToUCallBack(convGBK, UCNV_TO_U_CALLBACK_SKIP, nullptr, nullptr, nullptr, &status);
477 UChar ucharOther[100];
478 // from GBK to UNICODE
479 int32_t ucharLen = ucnv_toUChars(convGBK, ucharOther, 100, sourceGBK, sizeof(sourceGBK), &status);
480 ASSERT_TRUE(U_SUCCESS(status));
481
482 EXPECT_EQ(ucharLen, sizeof(unicode) / sizeof(UChar));
483 for (int32_t i = 0; i < ucharLen; ++i) {
484 EXPECT_EQ(ucharOther[i], unicode[i]);
485 }
486
487 ucnv_close(convGBK);
488 }
489
490 /**
491 * @tc.name: ConvertTest00010
492 * @tc.desc: Test ucnv_setToUCallBack UCNV_TO_U_CALLBACK_ESCAPE
493 * @tc.type: FUNC
494 */
495 HWTEST_F(ConvertTest, ConvertTest00010, TestSize.Level1)
496 {
497 /* "丂?疎" */
498 char sourceGBK[] = { 0x81, 0x40, 0x81, 0x7F, 0xAF, 0x45 };
499 /* "丂\x81疎" */
500 UChar unicode[] = { 0x4E02, 0x005C, 0x0078, 0x038, 0x0031, 0x007F, 0x758E };
501 UErrorCode status = U_ZERO_ERROR;
502 UConverter *convGBK = ucnv_open("GBK", &status);
503 ASSERT_TRUE(U_SUCCESS(status));
504 /* UCNV_ESCAPE_ICU UCNV_ESCAPE_JAVA UCNV_ESCAPE_C UCNV_ESCAPE_XML_DEC UCNV_ESCAPE_XML_HEX */
505 ucnv_setToUCallBack(convGBK, UCNV_TO_U_CALLBACK_ESCAPE, UCNV_ESCAPE_C, nullptr, nullptr, &status);
506 UChar ucharOther[100];
507 // from GBK to UNICODE
508 int32_t ucharLen = ucnv_toUChars(convGBK, ucharOther, 100, sourceGBK, sizeof(sourceGBK), &status);
509 ASSERT_TRUE(U_SUCCESS(status));
510
511 EXPECT_EQ(ucharLen, sizeof(unicode) / sizeof(UChar));
512 for (int32_t i = 0; i < ucharLen; ++i) {
513 EXPECT_EQ(ucharOther[i], unicode[i]);
514 }
515
516 ucnv_close(convGBK);
517 }
518 } // namespace I18n
519 } // namespace Global
520 } // namespace OHOS