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
16 #include "common_components/base/utf_helper.h"
17 #include "common_components/tests/test_helper.h"
18
19 using namespace common;
20 namespace common::test {
21 class UtfHelperTest : public common::test::BaseTestWithScope {
22 };
23
HWTEST_F_L0(UtfHelperTest,DecodeUTF16Test1)24 HWTEST_F_L0(UtfHelperTest, DecodeUTF16Test1)
25 {
26 uint16_t utf16[] = {0xD7FF};
27 size_t index = 0;
28 size_t len = 1;
29 uint32_t result = utf_helper::DecodeUTF16(utf16, len, &index, false);
30 EXPECT_EQ(result, 0xD7FF);
31
32 uint16_t utf16In[] = {0xDC00};
33 result = utf_helper::DecodeUTF16(utf16In, len, &index, false);
34 EXPECT_EQ(result, 0xDC00);
35
36 uint16_t utf16In1[] = {0xD800};
37 result = utf_helper::DecodeUTF16(utf16In1, len, &index, false);
38 EXPECT_EQ(result, 0xD800);
39
40 uint16_t utf16In2[] = {0xD7FF};
41 len = 2;
42 result = utf_helper::DecodeUTF16(utf16In2, len, &index, false);
43 EXPECT_EQ(result, 0xD7FF);
44
45 len = 1;
46 result = utf_helper::DecodeUTF16(utf16In2, len, &index, false);
47 EXPECT_EQ(result, 0xD7FF);
48
49 result = utf_helper::DecodeUTF16(utf16In, len, &index, false);
50 EXPECT_EQ(result, 0xDC00);
51 }
52
HWTEST_F_L0(UtfHelperTest,DecodeUTF16Test2)53 HWTEST_F_L0(UtfHelperTest, DecodeUTF16Test2)
54 {
55 size_t index = 0;
56 uint16_t utf16[] = {0xD800, 0xDC00};
57 size_t len = 2;
58 utf16[1] = 0xFFFF;
59 uint32_t result = utf_helper::DecodeUTF16(utf16, len, &index, false);
60 EXPECT_EQ(result, 0xD800);
61 }
62
HWTEST_F_L0(UtfHelperTest,DecodeUTF16Test3)63 HWTEST_F_L0(UtfHelperTest, DecodeUTF16Test3)
64 {
65 size_t index = 0;
66 uint16_t utf16[] = {0xD800, 0xDC00};
67 size_t len = 2;
68 uint32_t result = utf_helper::DecodeUTF16(utf16, len, &index, true);
69 EXPECT_EQ(result, 0xD800);
70
71 uint16_t utf16In[] = {0xD800, 0x0041};
72 result = utf_helper::DecodeUTF16(utf16In, len, &index, false);
73 EXPECT_EQ(result, 0xD800);
74 }
75
HWTEST_F_L0(UtfHelperTest,HandleAndDecodeInvalidUTF16Test1)76 HWTEST_F_L0(UtfHelperTest, HandleAndDecodeInvalidUTF16Test1)
77 {
78 uint16_t input[] = {0xDC00};
79 size_t index = 0;
80 size_t len = sizeof(input) / sizeof(input[0]);
81 uint32_t result = utf_helper::HandleAndDecodeInvalidUTF16(input, len, &index);
82 EXPECT_EQ(result, utf_helper::UTF16_REPLACEMENT_CHARACTER);
83 }
84
HWTEST_F_L0(UtfHelperTest,HandleAndDecodeInvalidUTF16Test2)85 HWTEST_F_L0(UtfHelperTest, HandleAndDecodeInvalidUTF16Test2)
86 {
87 uint16_t input[] = {0xD800};
88 size_t index = 0;
89 size_t len = sizeof(input) / sizeof(input[0]);
90 uint32_t result = utf_helper::HandleAndDecodeInvalidUTF16(input, len, &index);
91 EXPECT_EQ(result, utf_helper::UTF16_REPLACEMENT_CHARACTER);
92
93 uint16_t input1[] = {0xD800, 0xD800};
94 size_t len1 = sizeof(input1) / sizeof(input1[0]);
95 result = utf_helper::HandleAndDecodeInvalidUTF16(input1, len1, &index);
96 EXPECT_EQ(result, utf_helper::UTF16_REPLACEMENT_CHARACTER);
97
98 uint16_t input2[] = {'A'};
99 size_t len2 = sizeof(input2) / sizeof(input2[0]);
100 result = utf_helper::HandleAndDecodeInvalidUTF16(input2, len2, &index);
101 EXPECT_EQ(result, 'A');
102
103 uint16_t input3[] = {0xD800 ^ 0x01};
104 size_t len3 = sizeof(input3) / sizeof(input3[0]);
105 result = utf_helper::HandleAndDecodeInvalidUTF16(input3, len3, &index);
106 EXPECT_EQ(result, utf_helper::UTF16_REPLACEMENT_CHARACTER);
107 }
108
HWTEST_F_L0(UtfHelperTest,HandleAndDecodeInvalidUTF16Test3)109 HWTEST_F_L0(UtfHelperTest, HandleAndDecodeInvalidUTF16Test3)
110 {
111 uint16_t input[] = {0xDBFF, 0xDFFF};
112 size_t index = 0;
113 size_t len = sizeof(input) / sizeof(input[0]);
114 uint32_t expected = ((0xDBFF - utf_helper::DECODE_LEAD_LOW) << utf_helper::UTF16_OFFSET) +
115 (0xDFFF - utf_helper::DECODE_TRAIL_LOW) + utf_helper::DECODE_SECOND_FACTOR;
116 uint32_t result = utf_helper::HandleAndDecodeInvalidUTF16(input, len, &index);
117 EXPECT_EQ(result, expected);
118 }
119
HWTEST_F_L0(UtfHelperTest,HandleAndDecodeInvalidUTF16Test4)120 HWTEST_F_L0(UtfHelperTest, HandleAndDecodeInvalidUTF16Test4)
121 {
122 uint16_t input[] = {0xD800, 0xDC00};
123 size_t index = 0;
124 size_t len = sizeof(input) / sizeof(input[0]);
125 uint32_t expected = ((0xD800 - utf_helper::DECODE_LEAD_LOW) << utf_helper::UTF16_OFFSET) +
126 (0xDC00 - utf_helper::DECODE_TRAIL_LOW) + utf_helper::DECODE_SECOND_FACTOR;
127 uint32_t result = utf_helper::HandleAndDecodeInvalidUTF16(input, len, &index);
128 EXPECT_EQ(result, expected);
129 EXPECT_EQ(index, 1);
130 }
131
HWTEST_F_L0(UtfHelperTest,IsValidUTF8Test1)132 HWTEST_F_L0(UtfHelperTest, IsValidUTF8Test1)
133 {
134 std::vector<uint8_t> data = {0xED, 0xA0, 0x80};
135 EXPECT_FALSE(utf_helper::IsValidUTF8(data));
136
137 std::vector<uint8_t> data1 = {0xED, 0x90, 0x80};
138 EXPECT_TRUE(utf_helper::IsValidUTF8(data1));
139
140 std::vector<uint8_t> data2 = {0xED, 0xC0, 0x80};
141 EXPECT_FALSE(utf_helper::IsValidUTF8(data2));
142
143 std::vector<uint8_t> data3 = {0xED, 0x80, 0x80};
144 EXPECT_TRUE(utf_helper::IsValidUTF8(data3));
145
146 std::vector<uint8_t> data4 = {0xE0, 0xA0, 0x80};
147 EXPECT_TRUE(utf_helper::IsValidUTF8(data4));
148 }
149
HWTEST_F_L0(UtfHelperTest,IsValidUTF8Test2)150 HWTEST_F_L0(UtfHelperTest, IsValidUTF8Test2)
151 {
152 std::vector<uint8_t> data = {0xF4, 0x90, 0x80, 0x80};
153 EXPECT_FALSE(utf_helper::IsValidUTF8(data));
154
155 std::vector<uint8_t> data1 = {0xF5, 0x80, 0x80, 0x80};
156 EXPECT_FALSE(utf_helper::IsValidUTF8(data1));
157
158 std::vector<uint8_t> data2 = {0xF0, 0x90, 0x80, 0x80};
159 EXPECT_TRUE(utf_helper::IsValidUTF8(data2));
160
161 std::vector<uint8_t> data3 = {0xF1, 0x80, 0x80, 0x80};
162 EXPECT_TRUE(utf_helper::IsValidUTF8(data3));
163
164 std::vector<uint8_t> data4 = {0xF4, 0x80, 0x80, 0x80};
165 EXPECT_TRUE(utf_helper::IsValidUTF8(data4));
166 }
167
HWTEST_F_L0(UtfHelperTest,ConvertRegionUtf16ToUtf8Test3)168 HWTEST_F_L0(UtfHelperTest, ConvertRegionUtf16ToUtf8Test3)
169 {
170 uint8_t utf8Out[10];
171 size_t result = utf_helper::ConvertRegionUtf16ToUtf8(nullptr, utf8Out, 5, 10, 0, false, false, false);
172 EXPECT_EQ(result, 0);
173
174 uint16_t utf16In[] = {0x0041};
175 result = utf_helper::ConvertRegionUtf16ToUtf8(utf16In, nullptr, 1, sizeof(utf16In), 0, false, false, false);
176 EXPECT_EQ(result, 0);
177
178 result = utf_helper::ConvertRegionUtf16ToUtf8(utf16In, utf8Out, 1, 0, 0, false, false, false);
179 EXPECT_EQ(result, 0);
180
181 result = utf_helper::ConvertRegionUtf16ToUtf8(nullptr, utf8Out, 1, 0, 0, false, false, false);
182 EXPECT_EQ(result, 0);
183
184 result = utf_helper::ConvertRegionUtf16ToUtf8(utf16In, nullptr, 1, 0, 0, false, false, false);
185 EXPECT_EQ(result, 0);
186
187 result = utf_helper::ConvertRegionUtf16ToUtf8(nullptr, nullptr, 1, sizeof(utf8Out), 0, false, false, false);
188 EXPECT_EQ(result, 0);
189
190 result = utf_helper::ConvertRegionUtf16ToUtf8(nullptr, nullptr, 1, 0, 0, false, false, false);
191 EXPECT_EQ(result, 0);
192
193 result = utf_helper::ConvertRegionUtf16ToUtf8(utf16In, utf8Out, 1, sizeof(utf8Out), 0, false, false, false);
194 EXPECT_EQ(result, 1);
195 }
196
HWTEST_F_L0(UtfHelperTest,ConvertRegionUtf16ToLatin1Test)197 HWTEST_F_L0(UtfHelperTest, ConvertRegionUtf16ToLatin1Test)
198 {
199 uint8_t utf8Out[10];
200 size_t result = utf_helper::ConvertRegionUtf16ToLatin1(nullptr, utf8Out, 5, 10);
201 EXPECT_EQ(result, 0);
202
203 uint16_t utf16In[] = {0x0041};
204 result = utf_helper::ConvertRegionUtf16ToLatin1(utf16In, nullptr, 1, sizeof(utf16In));
205 EXPECT_EQ(result, 0);
206
207 result = utf_helper::ConvertRegionUtf16ToLatin1(utf16In, utf8Out, 1, 0);
208 EXPECT_EQ(result, 0);
209
210 result = utf_helper::ConvertRegionUtf16ToLatin1(nullptr, utf8Out, 1, 0);
211 EXPECT_EQ(result, 0);
212
213 result = utf_helper::ConvertRegionUtf16ToLatin1(utf16In, nullptr, 1, 0);
214 EXPECT_EQ(result, 0);
215
216 result = utf_helper::ConvertRegionUtf16ToLatin1(nullptr, nullptr, 1, sizeof(utf8Out));
217 EXPECT_EQ(result, 0);
218
219 result = utf_helper::ConvertRegionUtf16ToLatin1(nullptr, nullptr, 1, 0);
220 EXPECT_EQ(result, 0);
221
222 result = utf_helper::ConvertRegionUtf16ToLatin1(utf16In, utf8Out, 1, sizeof(utf8Out));
223 EXPECT_EQ(result, 1);
224
225 const uint16_t input[] = {0x0041, 0x0042, 0x0043};
226 uint8_t output[2] = {0};
227 result = utf_helper::ConvertRegionUtf16ToLatin1(input, output, 3, 2);
228 EXPECT_EQ(result, 2);
229 }
230
HWTEST_F_L0(UtfHelperTest,DebuggerConvertRegionUtf16ToUtf8Test)231 HWTEST_F_L0(UtfHelperTest, DebuggerConvertRegionUtf16ToUtf8Test)
232 {
233 uint8_t utf8Out[10];
234 size_t result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(nullptr, utf8Out, 5, sizeof(utf8Out), 0, false, false);
235 EXPECT_EQ(result, 0);
236
237 uint16_t utf16In[] = {0x0041};
238 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(utf16In, nullptr, 1, sizeof(utf16In), 0, false, false);
239 EXPECT_EQ(result, 0);
240
241 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(nullptr, nullptr, 1, sizeof(utf8Out), 0, false, false);
242 EXPECT_EQ(result, 0);
243
244 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(nullptr, utf8Out, 1, 0, 0, false, false);
245 EXPECT_EQ(result, 0);
246
247 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(nullptr, utf8Out, 1, 0, 0, false, false);
248 EXPECT_EQ(result, 0);
249
250 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(nullptr, nullptr, 1, 0, 0, false, false);
251 EXPECT_EQ(result, 0);
252
253 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(utf16In, utf8Out, 1, 0, 0, false, false);
254 EXPECT_EQ(result, 0);
255
256 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(utf16In, utf8Out, 1, sizeof(utf8Out), 0, false, false);
257 EXPECT_EQ(result, 1);
258
259 uint16_t utf16In1[] = {0x0041, 0x0042, 0x0043};
260 result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(utf16In1, nullptr, 3, 0, 0, false, false);
261 EXPECT_EQ(result, 0);
262 }
263
HWTEST_F_L0(UtfHelperTest,DecodeUTF16Test4)264 HWTEST_F_L0(UtfHelperTest, DecodeUTF16Test4)
265 {
266 uint16_t utf16[] = {0xD800, 0xDC00};
267 size_t index = 0;
268 size_t len = sizeof(utf16) / sizeof(utf16[0]);
269
270 uint32_t result = utf_helper::DecodeUTF16(utf16, len, &index, false);
271 EXPECT_EQ(result, 0x10000);
272 EXPECT_EQ(index, 1);
273 }
274
HWTEST_F_L0(UtfHelperTest,Utf8ToUtf16Size_LastByteIsTwoByteStart_TrimLastByte)275 HWTEST_F_L0(UtfHelperTest, Utf8ToUtf16Size_LastByteIsTwoByteStart_TrimLastByte)
276 {
277 const uint8_t utf8[] = {0xC0};
278 size_t utf8Len = sizeof(utf8);
279
280 size_t result = utf_helper::Utf8ToUtf16Size(utf8, utf8Len);
281 EXPECT_EQ(result, 1);
282 }
283
HWTEST_F_L0(UtfHelperTest,Utf8ToUtf16Size_LastTwoBytesStartWithThreeByteHeader_TrimTwoBytes)284 HWTEST_F_L0(UtfHelperTest, Utf8ToUtf16Size_LastTwoBytesStartWithThreeByteHeader_TrimTwoBytes)
285 {
286 const uint8_t utf8[] = {0xE2, 0x82};
287 size_t utf8Len = sizeof(utf8);
288
289 size_t result = utf_helper::Utf8ToUtf16Size(utf8, utf8Len);
290 EXPECT_EQ(result, 2);
291 }
292
HWTEST_F_L0(UtfHelperTest,Utf8ToUtf16Size_IncompleteSequenceAtEnd_ReturnsSizeWithoutInvalid)293 HWTEST_F_L0(UtfHelperTest, Utf8ToUtf16Size_IncompleteSequenceAtEnd_ReturnsSizeWithoutInvalid)
294 {
295 const uint8_t utf8[] = {0xF0, 0x90, 0x8D};
296 size_t result = utf_helper::Utf8ToUtf16Size(utf8, 3);
297 EXPECT_EQ(result, 3);
298 }
299
HWTEST_F_L0(UtfHelperTest,DebuggerConvertRegionUtf16ToUtf8_ZeroCodepoint_WriteNulChar)300 HWTEST_F_L0(UtfHelperTest, DebuggerConvertRegionUtf16ToUtf8_ZeroCodepoint_WriteNulChar)
301 {
302 uint16_t utf16In[] = {0x0000};
303 uint8_t utf8Out[10] = {0};
304 size_t utf16Len = 1;
305 size_t utf8Len = sizeof(utf8Out);
306 size_t start = 0;
307 bool modify = false;
308 bool isWriteBuffer = true;
309
310 size_t result = utf_helper::DebuggerConvertRegionUtf16ToUtf8(
311 utf16In, utf8Out, utf16Len, utf8Len, start, modify, isWriteBuffer);
312
313 EXPECT_EQ(result, 1);
314 EXPECT_EQ(utf8Out[0], 0x00U);
315 }
316
HWTEST_F_L0(UtfHelperTest,ConvertUtf16ToUtf8_NulChar_WriteBufferMode_ReturnsZeroByte)317 HWTEST_F_L0(UtfHelperTest, ConvertUtf16ToUtf8_NulChar_WriteBufferMode_ReturnsZeroByte)
318 {
319 uint16_t d0 = 0x0000;
320 uint16_t d1 = 0;
321 bool modify = false;
322 bool isWriteBuffer = true;
323
324 utf_helper::Utf8Char result = utf_helper::ConvertUtf16ToUtf8(d0, d1, modify, isWriteBuffer);
325
326 EXPECT_EQ(result.n, 1);
327 EXPECT_EQ(result.ch[0], 0x00U);
328 }
329 } // namespace common::test