]> git.ipfire.org Git - thirdparty/u-boot.git/blame - test/unicode_ut.c
projects / thirdparty / u-boot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
usb: composite: Move bitmap related operations to ./include/linux/bitmap.h
[thirdparty/u-boot.git] / test / unicode_ut.c
CommitLineData
f11a164b
HS		 1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Unit tests for Unicode functions
4 *
5 * Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de>
6 */
7
8#include <common.h>
9#include <charset.h>
10#include <command.h>
11#include <errno.h>
12#include <test/test.h>
13#include <test/suites.h>
14#include <test/ut.h>
15
16/* Linker list entry for a Unicode test */
17#define UNICODE_TEST(_name) UNIT_TEST(_name, 0, unicode_test)
18
19/* Constants c1-c4 and d1-d4 encode the same letters */
20
21/* Six characters translating to one utf-8 byte each. */
22static const u16 c1[] = {0x55, 0x2d, 0x42, 0x6f, 0x6f, 0x74, 0x00};
23/* One character translating to two utf-8 bytes */
24static const u16 c2[] = {0x6b, 0x61, 0x66, 0x62, 0xe1, 0x74, 0x75, 0x72, 0x00};
25/* Three characters translating to three utf-8 bytes each */
26static const u16 c3[] = {0x6f5c, 0x6c34, 0x8266, 0x00};
27/* Three letters translating to four utf-8 bytes each */
28static const u16 c4[] = {0xd801, 0xdc8d, 0xd801, 0xdc96, 0xd801, 0xdc87,
29 0x0000};
30
31/* Illegal utf-16 strings */
32static const u16 i1[] = {0x69, 0x31, 0xdc87, 0x6c, 0x00};
33static const u16 i2[] = {0x69, 0x32, 0xd801, 0xd801, 0x6c, 0x00};
34static const u16 i3[] = {0x69, 0x33, 0xd801, 0x00};
35
36/* Six characters translating to one utf-16 word each. */
37static const char d1[] = {0x55, 0x2d, 0x42, 0x6f, 0x6f, 0x74, 0x00};
38/* Eight characters translating to one utf-16 word each */
39static const char d2[] = {0x6b, 0x61, 0x66, 0x62, 0xc3, 0xa1, 0x74, 0x75,
40 0x72, 0x00};
41/* Three characters translating to one utf-16 word each */
42static const char d3[] = {0xe6, 0xbd, 0x9c, 0xe6, 0xb0, 0xb4, 0xe8, 0x89,
43 0xa6, 0x00};
44/* Three letters translating to two utf-16 word each */
45static const char d4[] = {0xf0, 0x90, 0x92, 0x8d, 0xf0, 0x90, 0x92, 0x96,
46 0xf0, 0x90, 0x92, 0x87, 0x00};
47
48/* Illegal utf-8 strings */
49static const char j1[] = {0x6a, 0x31, 0xa1, 0x6c, 0x00};
50static const char j2[] = {0x6a, 0x32, 0xc3, 0xc3, 0x6c, 0x00};
51static const char j3[] = {0x6a, 0x33, 0xf0, 0x90, 0xf0, 0x00};
52
fbba2f67
HS		 53/* U-Boot uses UTF-16 strings in the EFI context only. */
54#if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD)
55static int ut_string16(struct unit_test_state *uts)
56{
57 char buf[20];
58
59 /* Test length and precision */
60 memset(buf, 0xff, sizeof(buf));
61 sprintf(buf, "%8.6ls", c2);
62 ut_asserteq(' ', buf[1]);
63 ut_assert(!strncmp(&buf[2], d2, 7));
64 ut_assert(!buf[9]);
65
66 memset(buf, 0xff, sizeof(buf));
67 sprintf(buf, "%8.6ls", c4);
68 ut_asserteq(' ', buf[4]);
69 ut_assert(!strncmp(&buf[5], d4, 12));
70 ut_assert(!buf[17]);
71
72 memset(buf, 0xff, sizeof(buf));
73 sprintf(buf, "%-8.2ls", c4);
74 ut_asserteq(' ', buf[8]);
75 ut_assert(!strncmp(buf, d4, 8));
76 ut_assert(!buf[14]);
77
78 /* Test handling of illegal utf-16 sequences */
79 memset(buf, 0xff, sizeof(buf));
80 sprintf(buf, "%ls", i1);
81 ut_asserteq_str("i1?l", buf);
82
83 memset(buf, 0xff, sizeof(buf));
84 sprintf(buf, "%ls", i2);
85 ut_asserteq_str("i2?l", buf);
86
87 memset(buf, 0xff, sizeof(buf));
88 sprintf(buf, "%ls", i3);
89 ut_asserteq_str("i3?", buf);
90
91 return 0;
92}
93UNICODE_TEST(ut_string16);
94#endif
95
f11a164b
HS		 96static int ut_utf8_get(struct unit_test_state *uts)
97{
98 const char *s;
99 s32 code;
100 int i;
101
102 /* Check characters less than 0x800 */
103 s = d2;
104 for (i = 0; i < 8; ++i) {
105 code = utf8_get((const char **)&s);
106 /* c2 is the utf-8 encoding of d2 */
107 ut_asserteq(c2[i], code);
108 if (!code)
109 break;
110 }
111 ut_asserteq_ptr(s, d2 + 9)
112
113 /* Check characters less than 0x10000 */
114 s = d3;
115 for (i = 0; i < 4; ++i) {
116 code = utf8_get((const char **)&s);
117 /* c3 is the utf-8 encoding of d3 */
118 ut_asserteq(c3[i], code);
119 if (!code)
120 break;
121 }
122 ut_asserteq_ptr(s, d3 + 9)
123
124 /* Check character greater 0xffff */
125 s = d4;
126 code = utf8_get((const char **)&s);
127 ut_asserteq(0x0001048d, code);
128 ut_asserteq_ptr(s, d4 + 4);
129
130 return 0;
131}
132UNICODE_TEST(ut_utf8_get);
133
134static int ut_utf8_put(struct unit_test_state *uts)
135{
136 char buffer[8] = { 0, };
137 char *pos;
138
139 /* Commercial at, translates to one character */
140 pos = buffer;
141 ut_assert(!utf8_put('@', &pos))
142 ut_asserteq(1, pos - buffer);
143 ut_asserteq('@', buffer[0]);
144 ut_assert(!buffer[1]);
145
146 /* Latin letter G with acute, translates to two charactes */
147 pos = buffer;
148 ut_assert(!utf8_put(0x1f4, &pos));
149 ut_asserteq(2, pos - buffer);
150 ut_asserteq_str("\xc7\xb4", buffer);
151
152 /* Tagalog letter i, translates to three characters */
153 pos = buffer;
154 ut_assert(!utf8_put(0x1701, &pos));
155 ut_asserteq(3, pos - buffer);
156 ut_asserteq_str("\xe1\x9c\x81", buffer);
157
158 /* Hamster face, translates to four characters */
159 pos = buffer;
160 ut_assert(!utf8_put(0x1f439, &pos));
161 ut_asserteq(4, pos - buffer);
162 ut_asserteq_str("\xf0\x9f\x90\xb9", buffer);
163
164 /* Illegal code */
165 pos = buffer;
166 ut_asserteq(-1, utf8_put(0xd888, &pos));
167
168 return 0;
169}
170UNICODE_TEST(ut_utf8_put);
171
172static int ut_utf8_utf16_strlen(struct unit_test_state *uts)
173{
174 ut_asserteq(6, utf8_utf16_strlen(d1));
175 ut_asserteq(8, utf8_utf16_strlen(d2));
176 ut_asserteq(3, utf8_utf16_strlen(d3));
177 ut_asserteq(6, utf8_utf16_strlen(d4));
178
179 /* illegal utf-8 sequences */
180 ut_asserteq(4, utf8_utf16_strlen(j1));
35cbb796 181 ut_asserteq(4, utf8_utf16_strlen(j2));
f11a164b
HS		 182 ut_asserteq(3, utf8_utf16_strlen(j3));
183
184 return 0;
185}
186UNICODE_TEST(ut_utf8_utf16_strlen);
187
188static int ut_utf8_utf16_strnlen(struct unit_test_state *uts)
189{
190 ut_asserteq(3, utf8_utf16_strnlen(d1, 3));
191 ut_asserteq(6, utf8_utf16_strnlen(d1, 13));
192 ut_asserteq(6, utf8_utf16_strnlen(d2, 6));
193 ut_asserteq(2, utf8_utf16_strnlen(d3, 2));
194 ut_asserteq(4, utf8_utf16_strnlen(d4, 2));
195 ut_asserteq(6, utf8_utf16_strnlen(d4, 3));
196
197 /* illegal utf-8 sequences */
198 ut_asserteq(4, utf8_utf16_strnlen(j1, 16));
35cbb796 199 ut_asserteq(4, utf8_utf16_strnlen(j2, 16));
f11a164b
HS		 200 ut_asserteq(3, utf8_utf16_strnlen(j3, 16));
201
202 return 0;
203}
204UNICODE_TEST(ut_utf8_utf16_strnlen);
205
206/**
207 * ut_u16_strcmp() - Compare to u16 strings.
208 *
209 * @a1: first string
210 * @a2: second string
211 * @count: number of u16 to compare
212 * Return: -1 if a1 < a2, 0 if a1 == a2, 1 if a1 > a2
213 */
214static int ut_u16_strcmp(const u16 *a1, const u16 *a2, size_t count)
215{
216 for (; (*a1 || *a2) && count; ++a1, ++a2, --count) {
217 if (*a1 < *a2)
218 return -1;
219 if (*a1 > *a2)
220 return 1;
221 }
222 return 0;
223}
224
225static int ut_utf8_utf16_strcpy(struct unit_test_state *uts)
226{
227 u16 buf[16];
228 u16 *pos;
229
230 pos = buf;
231 utf8_utf16_strcpy(&pos, d1);
232 ut_asserteq(6, pos - buf);
233 ut_assert(!ut_u16_strcmp(buf, c1, SIZE_MAX));
234
235 pos = buf;
236 utf8_utf16_strcpy(&pos, d2);
237 ut_asserteq(8, pos - buf);
238 ut_assert(!ut_u16_strcmp(buf, c2, SIZE_MAX));
239
240 pos = buf;
241 utf8_utf16_strcpy(&pos, d3);
242 ut_asserteq(3, pos - buf);
243 ut_assert(!ut_u16_strcmp(buf, c3, SIZE_MAX));
244
245 pos = buf;
246 utf8_utf16_strcpy(&pos, d4);
247 ut_asserteq(6, pos - buf);
248 ut_assert(!ut_u16_strcmp(buf, c4, SIZE_MAX));
249
250 /* Illegal utf-8 strings */
251 pos = buf;
252 utf8_utf16_strcpy(&pos, j1);
253 ut_asserteq(4, pos - buf);
254 ut_assert(!ut_u16_strcmp(buf, L"j1?l", SIZE_MAX));
255
256 pos = buf;
257 utf8_utf16_strcpy(&pos, j2);
35cbb796
HS		 258 ut_asserteq(4, pos - buf);
259 ut_assert(!ut_u16_strcmp(buf, L"j2?l", SIZE_MAX));
f11a164b
HS		 260
261 pos = buf;
262 utf8_utf16_strcpy(&pos, j3);
263 ut_asserteq(3, pos - buf);
264 ut_assert(!ut_u16_strcmp(buf, L"j3?", SIZE_MAX));
265
266 return 0;
267}
268UNICODE_TEST(ut_utf8_utf16_strcpy);
269
270int ut_utf8_utf16_strncpy(struct unit_test_state *uts)
271{
272 u16 buf[16];
273 u16 *pos;
274
275 pos = buf;
276 memset(buf, 0, sizeof(buf));
277 utf8_utf16_strncpy(&pos, d1, 4);
278 ut_asserteq(4, pos - buf);
279 ut_assert(!buf[4]);
280 ut_assert(!ut_u16_strcmp(buf, c1, 4));
281
282 pos = buf;
283 memset(buf, 0, sizeof(buf));
284 utf8_utf16_strncpy(&pos, d2, 10);
285 ut_asserteq(8, pos - buf);
286 ut_assert(buf[4]);
287 ut_assert(!ut_u16_strcmp(buf, c2, SIZE_MAX));
288
289 pos = buf;
290 memset(buf, 0, sizeof(buf));
291 utf8_utf16_strncpy(&pos, d3, 2);
292 ut_asserteq(2, pos - buf);
293 ut_assert(!buf[2]);
294 ut_assert(!ut_u16_strcmp(buf, c3, 2));
295
296 pos = buf;
297 memset(buf, 0, sizeof(buf));
298 utf8_utf16_strncpy(&pos, d4, 2);
299 ut_asserteq(4, pos - buf);
300 ut_assert(!buf[4]);
301 ut_assert(!ut_u16_strcmp(buf, c4, 4));
302
303 pos = buf;
304 memset(buf, 0, sizeof(buf));
305 utf8_utf16_strncpy(&pos, d4, 10);
306 ut_asserteq(6, pos - buf);
307 ut_assert(buf[5]);
308 ut_assert(!ut_u16_strcmp(buf, c4, SIZE_MAX));
309
310 return 0;
311}
312UNICODE_TEST(ut_utf8_utf16_strncpy);
313
314static int ut_utf16_get(struct unit_test_state *uts)
315{
316 const u16 *s;
317 s32 code;
318 int i;
319
320 /* Check characters less than 0x10000 */
321 s = c2;
322 for (i = 0; i < 9; ++i) {
323 code = utf16_get((const u16 **)&s);
324 ut_asserteq(c2[i], code);
325 if (!code)
326 break;
327 }
328 ut_asserteq_ptr(c2 + 8, s);
329
330 /* Check character greater 0xffff */
331 s = c4;
332 code = utf16_get((const u16 **)&s);
333 ut_asserteq(0x0001048d, code);
334 ut_asserteq_ptr(c4 + 2, s);
335
336 return 0;
337}
338UNICODE_TEST(ut_utf16_get);
339
340static int ut_utf16_put(struct unit_test_state *uts)
341{
342 u16 buffer[4] = { 0, };
343 u16 *pos;
344
345 /* Commercial at, translates to one word */
346 pos = buffer;
347 ut_assert(!utf16_put('@', &pos));
348 ut_asserteq(1, pos - buffer);
349 ut_asserteq((u16)'@', buffer[0]);
350 ut_assert(!buffer[1]);
351
352 /* Hamster face, translates to two words */
353 pos = buffer;
354 ut_assert(!utf16_put(0x1f439, &pos));
355 ut_asserteq(2, pos - buffer);
356 ut_asserteq((u16)0xd83d, buffer[0]);
357 ut_asserteq((u16)0xdc39, buffer[1]);
358 ut_assert(!buffer[2]);
359
360 /* Illegal code */
361 pos = buffer;
362 ut_asserteq(-1, utf16_put(0xd888, &pos));
363
364 return 0;
365}
366UNICODE_TEST(ut_utf16_put);
367
368int ut_utf16_strnlen(struct unit_test_state *uts)
369{
370 ut_asserteq(3, utf16_strnlen(c1, 3));
371 ut_asserteq(6, utf16_strnlen(c1, 13));
372 ut_asserteq(6, utf16_strnlen(c2, 6));
373 ut_asserteq(2, utf16_strnlen(c3, 2));
374 ut_asserteq(2, utf16_strnlen(c4, 2));
375 ut_asserteq(3, utf16_strnlen(c4, 3));
376
377 /* illegal utf-16 word sequences */
378 ut_asserteq(4, utf16_strnlen(i1, 16));
379 ut_asserteq(4, utf16_strnlen(i2, 16));
380 ut_asserteq(3, utf16_strnlen(i3, 16));
381
382 return 0;
383}
384UNICODE_TEST(ut_utf16_strnlen);
385
386int ut_utf16_utf8_strlen(struct unit_test_state *uts)
387{
388 ut_asserteq(6, utf16_utf8_strlen(c1));
389 ut_asserteq(9, utf16_utf8_strlen(c2));
390 ut_asserteq(9, utf16_utf8_strlen(c3));
391 ut_asserteq(12, utf16_utf8_strlen(c4));
392
393 /* illegal utf-16 word sequences */
394 ut_asserteq(4, utf16_utf8_strlen(i1));
395 ut_asserteq(4, utf16_utf8_strlen(i2));
396 ut_asserteq(3, utf16_utf8_strlen(i3));
397
398 return 0;
399}
400UNICODE_TEST(ut_utf16_utf8_strlen);
401
402int ut_utf16_utf8_strnlen(struct unit_test_state *uts)
403{
404 ut_asserteq(3, utf16_utf8_strnlen(c1, 3));
405 ut_asserteq(6, utf16_utf8_strnlen(c1, 13));
406 ut_asserteq(7, utf16_utf8_strnlen(c2, 6));
407 ut_asserteq(6, utf16_utf8_strnlen(c3, 2));
408 ut_asserteq(8, utf16_utf8_strnlen(c4, 2));
409 ut_asserteq(12, utf16_utf8_strnlen(c4, 3));
410 return 0;
411}
412UNICODE_TEST(ut_utf16_utf8_strnlen);
413
414int ut_utf16_utf8_strcpy(struct unit_test_state *uts)
415{
416 char buf[16];
417 char *pos;
418
419 pos = buf;
420 utf16_utf8_strcpy(&pos, c1);
421 ut_asserteq(6, pos - buf);
422 ut_asserteq_str(d1, buf);
423
424 pos = buf;
425 utf16_utf8_strcpy(&pos, c2);
426 ut_asserteq(9, pos - buf);
427 ut_asserteq_str(d2, buf);
428
429 pos = buf;
430 utf16_utf8_strcpy(&pos, c3);
431 ut_asserteq(9, pos - buf);
432 ut_asserteq_str(d3, buf);
433
434 pos = buf;
435 utf16_utf8_strcpy(&pos, c4);
436 ut_asserteq(12, pos - buf);
437 ut_asserteq_str(d4, buf);
438
439 /* Illegal utf-16 strings */
440 pos = buf;
441 utf16_utf8_strcpy(&pos, i1);
442 ut_asserteq(4, pos - buf);
443 ut_asserteq_str("i1?l", buf);
444
445 pos = buf;
446 utf16_utf8_strcpy(&pos, i2);
447 ut_asserteq(4, pos - buf);
448 ut_asserteq_str("i2?l", buf);
449
450 pos = buf;
451 utf16_utf8_strcpy(&pos, i3);
452 ut_asserteq(3, pos - buf);
453 ut_asserteq_str("i3?", buf);
454
455 return 0;
456}
457UNICODE_TEST(ut_utf16_utf8_strcpy);
458
459int ut_utf16_utf8_strncpy(struct unit_test_state *uts)
460{
461 char buf[16];
462 char *pos;
463
464 pos = buf;
465 memset(buf, 0, sizeof(buf));
466 utf16_utf8_strncpy(&pos, c1, 4);
467 ut_asserteq(4, pos - buf);
468 ut_assert(!buf[4]);
469 ut_assert(!strncmp(buf, d1, 4));
470
471 pos = buf;
472 memset(buf, 0, sizeof(buf));
473 utf16_utf8_strncpy(&pos, c2, 10);
474 ut_asserteq(9, pos - buf);
475 ut_assert(buf[4]);
476 ut_assert(!strncmp(buf, d2, SIZE_MAX));
477
478 pos = buf;
479 memset(buf, 0, sizeof(buf));
480 utf16_utf8_strncpy(&pos, c3, 2);
481 ut_asserteq(6, pos - buf);
482 ut_assert(!buf[6]);
483 ut_assert(!strncmp(buf, d3, 6));
484
485 pos = buf;
486 memset(buf, 0, sizeof(buf));
487 utf16_utf8_strncpy(&pos, c4, 2);
488 ut_asserteq(8, pos - buf);
489 ut_assert(!buf[8]);
490 ut_assert(!strncmp(buf, d4, 8));
491
492 pos = buf;
493 memset(buf, 0, sizeof(buf));
494 utf16_utf8_strncpy(&pos, c4, 10);
495 ut_asserteq(12, pos - buf);
496 ut_assert(buf[5]);
497 ut_assert(!strncmp(buf, d4, SIZE_MAX));
498
499 return 0;
500}
501UNICODE_TEST(ut_utf16_utf8_strncpy);
502
1a1012a1
HS		 503int ut_utf_to_lower(struct unit_test_state *uts)
504{
505 ut_asserteq('@', utf_to_lower('@'));
506 ut_asserteq('a', utf_to_lower('A'));
507 ut_asserteq('z', utf_to_lower('Z'));
508 ut_asserteq('[', utf_to_lower('['));
509 ut_asserteq('m', utf_to_lower('m'));
510 /* Latin letter O with diaresis (umlaut) */
511 ut_asserteq(0x00f6, utf_to_lower(0x00d6));
512#ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
513 /* Cyrillic letter I*/
514 ut_asserteq(0x0438, utf_to_lower(0x0418));
515#endif
516 return 0;
517}
518UNICODE_TEST(ut_utf_to_lower);
519
520int ut_utf_to_upper(struct unit_test_state *uts)
521{
522 ut_asserteq('`', utf_to_upper('`'));
523 ut_asserteq('A', utf_to_upper('a'));
524 ut_asserteq('Z', utf_to_upper('z'));
525 ut_asserteq('{', utf_to_upper('{'));
526 ut_asserteq('M', utf_to_upper('M'));
527 /* Latin letter O with diaresis (umlaut) */
528 ut_asserteq(0x00d6, utf_to_upper(0x00f6));
529#ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
530 /* Cyrillic letter I */
531 ut_asserteq(0x0418, utf_to_upper(0x0438));
532#endif
533 return 0;
534}
535UNICODE_TEST(ut_utf_to_upper);
536
f11a164b
HS		 537int do_ut_unicode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
538{
539 struct unit_test *tests = ll_entry_start(struct unit_test, unicode_test);
540 const int n_ents = ll_entry_count(struct unit_test, unicode_test);
541
542 return cmd_ut_category("Unicode", tests, n_ents, argc, argv);
543}
"Das U-Boot" Source Tree