diff options
Diffstat (limited to 'libraries/eina/src/tests/eina_test_ustr.c')
-rw-r--r-- | libraries/eina/src/tests/eina_test_ustr.c | 593 |
1 files changed, 0 insertions, 593 deletions
diff --git a/libraries/eina/src/tests/eina_test_ustr.c b/libraries/eina/src/tests/eina_test_ustr.c deleted file mode 100644 index 75126cc..0000000 --- a/libraries/eina/src/tests/eina_test_ustr.c +++ /dev/null | |||
@@ -1,593 +0,0 @@ | |||
1 | /* EINA - EFL data type library | ||
2 | * Copyright (C) 2010 Brett Nash | ||
3 | * | ||
4 | * This library is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * This library is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with this library; | ||
16 | * if not, see <http://www.gnu.org/licenses/>. | ||
17 | */ | ||
18 | |||
19 | #ifdef HAVE_CONFIG_H | ||
20 | # include "config.h" | ||
21 | #endif | ||
22 | |||
23 | #include <stdlib.h> | ||
24 | #include <stdio.h> | ||
25 | #include <string.h> | ||
26 | #include <time.h> | ||
27 | |||
28 | #include "eina_suite.h" | ||
29 | #include "Eina.h" | ||
30 | |||
31 | #ifdef EINA_SAFETY_CHECKS | ||
32 | struct log_ctx { | ||
33 | const char *msg; | ||
34 | const char *fnc; | ||
35 | Eina_Bool did; | ||
36 | }; | ||
37 | |||
38 | /* tests should not output on success, just uncomment this for debugging */ | ||
39 | //#define SHOW_LOG 1 | ||
40 | |||
41 | static void | ||
42 | _eina_test_safety_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args __UNUSED__) | ||
43 | { | ||
44 | struct log_ctx *ctx = data; | ||
45 | va_list cp_args; | ||
46 | const char *str; | ||
47 | |||
48 | va_copy(cp_args, args); | ||
49 | str = va_arg(cp_args, const char *); | ||
50 | va_end(cp_args); | ||
51 | |||
52 | ck_assert_int_eq(level, EINA_LOG_LEVEL_ERR); | ||
53 | ck_assert_str_eq(fmt, "%s"); | ||
54 | ck_assert_str_eq(ctx->msg, str); | ||
55 | ck_assert_str_eq(ctx->fnc, fnc); | ||
56 | ctx->did = EINA_TRUE; | ||
57 | |||
58 | #ifdef SHOW_LOG | ||
59 | eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, NULL, args); | ||
60 | #else | ||
61 | (void)d; | ||
62 | (void)file; | ||
63 | (void)line; | ||
64 | #endif | ||
65 | } | ||
66 | #endif | ||
67 | |||
68 | static const Eina_Unicode STR1[] = {'P', 'a', 'n', 't', 's',' ', 'O', 'n', 0}; | ||
69 | static const Eina_Unicode STR2[] = {'P', 'a', 'n', 't', 's',' ', 'O', 'f', 'f', 0}; | ||
70 | static const Eina_Unicode STR3[] = {'P', 'a', 'n', 't', 's',' ', 'O', 'n', 0}; | ||
71 | static const Eina_Unicode STR4[] = {'A', 0}; | ||
72 | static const Eina_Unicode EMPTYSTR[] = {0}; | ||
73 | |||
74 | START_TEST(eina_unicode_strcmp_test) | ||
75 | { | ||
76 | eina_init(); | ||
77 | |||
78 | /* 1 & 2 */ | ||
79 | fail_if(eina_unicode_strcmp(STR1,STR2) == 0); | ||
80 | fail_if(eina_unicode_strcmp(STR1,STR2) < 1); | ||
81 | |||
82 | /* 1 & 3 */ | ||
83 | fail_if(eina_unicode_strcmp(STR1, STR3) != 0); | ||
84 | |||
85 | /* 1 & 4 */ | ||
86 | fail_if(eina_unicode_strcmp(STR1, STR4) == 0); | ||
87 | fail_if(eina_unicode_strcmp(STR1, STR4) > 1); | ||
88 | |||
89 | /* 1 & empty */ | ||
90 | fail_if(eina_unicode_strcmp(STR1, EMPTYSTR) < 1); | ||
91 | |||
92 | /* Self tests */ | ||
93 | fail_if(eina_unicode_strcmp(STR1, STR1) != 0); | ||
94 | fail_if(eina_unicode_strcmp(STR2, STR2) != 0); | ||
95 | fail_if(eina_unicode_strcmp(STR3, STR3) != 0); | ||
96 | fail_if(eina_unicode_strcmp(STR4, STR4) != 0); | ||
97 | fail_if(eina_unicode_strcmp(EMPTYSTR, EMPTYSTR) != 0); | ||
98 | |||
99 | eina_shutdown(); | ||
100 | } | ||
101 | END_TEST | ||
102 | |||
103 | START_TEST(eina_unicode_strcpy_test) | ||
104 | { | ||
105 | Eina_Unicode buf[10] = { 0 }; | ||
106 | Eina_Unicode *rv; | ||
107 | |||
108 | eina_init(); | ||
109 | |||
110 | rv = eina_unicode_strcpy(buf,STR1); | ||
111 | fail_if(rv != buf); | ||
112 | fail_if(eina_unicode_strcmp(buf,STR1) != 0); | ||
113 | |||
114 | rv = eina_unicode_strcpy(buf,STR2); | ||
115 | fail_if(rv != buf); | ||
116 | fail_if(eina_unicode_strcmp(buf,STR2) != 0); | ||
117 | |||
118 | /* Now a shorter string */ | ||
119 | rv = eina_unicode_strcpy(buf,STR2); | ||
120 | fail_if(rv != buf); | ||
121 | fail_if(eina_unicode_strcmp(buf,STR2) != 0); | ||
122 | |||
123 | /* Really short string */ | ||
124 | rv = eina_unicode_strcpy(buf,STR4); | ||
125 | fail_if(rv != buf); | ||
126 | fail_if(eina_unicode_strcmp(buf,STR4) != 0); | ||
127 | fail_if(buf[2] != 'n'); /* check old buf is there */ | ||
128 | |||
129 | buf[1] = '7'; | ||
130 | rv = eina_unicode_strcpy(buf,EMPTYSTR); | ||
131 | fail_if(rv != buf); | ||
132 | fail_if(buf[0] != 0); | ||
133 | fail_if(buf[1] != '7'); | ||
134 | |||
135 | eina_shutdown(); | ||
136 | } | ||
137 | END_TEST | ||
138 | |||
139 | START_TEST(eina_unicode_strncpy_test) | ||
140 | { | ||
141 | Eina_Unicode buf[10] = { 0 }; | ||
142 | Eina_Unicode *rv; | ||
143 | |||
144 | eina_init(); | ||
145 | |||
146 | rv = eina_unicode_strncpy(buf,STR1,9); | ||
147 | fail_if(rv != buf); | ||
148 | fail_if(eina_unicode_strcmp(buf,STR1) != 0); | ||
149 | |||
150 | buf[1] = '7'; | ||
151 | rv = eina_unicode_strncpy(buf,STR1,1); | ||
152 | fail_if(rv != buf); | ||
153 | fail_if(buf[1] != '7'); | ||
154 | fail_if(buf[0] != STR1[0]); | ||
155 | |||
156 | buf[9] = '7'; | ||
157 | rv = eina_unicode_strncpy(buf, STR4, 10); | ||
158 | fail_if(rv != buf); | ||
159 | fail_if(eina_unicode_strcmp(buf,STR4) != 0); | ||
160 | fail_if(buf[9] != 0); | ||
161 | |||
162 | buf[0] = '7'; | ||
163 | rv = eina_unicode_strncpy(buf, STR1, 0); | ||
164 | fail_if(buf[0] != '7'); | ||
165 | |||
166 | #ifdef EINA_SAFETY_CHECKS | ||
167 | { | ||
168 | struct log_ctx ctx; | ||
169 | |||
170 | #define TEST_MAGIC_SAFETY(fn, _msg) \ | ||
171 | ctx.msg = _msg; \ | ||
172 | ctx.fnc = fn; \ | ||
173 | ctx.did = EINA_FALSE | ||
174 | |||
175 | eina_log_print_cb_set(_eina_test_safety_print_cb, &ctx); | ||
176 | |||
177 | /* may segfault */ | ||
178 | buf[0] = '7'; | ||
179 | #ifdef SHOW_LOG | ||
180 | fprintf(stderr, "you should have a safety check failure below:\n"); | ||
181 | #endif | ||
182 | TEST_MAGIC_SAFETY("eina_unicode_strncpy", | ||
183 | "safety check failed: source == NULL"); | ||
184 | rv = eina_unicode_strncpy(buf, NULL, 0); | ||
185 | fail_if(buf[0] != '7'); | ||
186 | fail_unless(ctx.did); | ||
187 | |||
188 | /* Hopefully won't segfault */ | ||
189 | #ifdef SHOW_LOG | ||
190 | fprintf(stderr, "you should have a safety check failure below:\n"); | ||
191 | #endif | ||
192 | TEST_MAGIC_SAFETY("eina_unicode_strncpy", | ||
193 | "safety check failed: dest == NULL"); | ||
194 | rv = eina_unicode_strncpy(NULL, STR1, 0); | ||
195 | fail_if(rv != NULL); | ||
196 | fail_unless(ctx.did); | ||
197 | |||
198 | eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); | ||
199 | #undef TEST_MAGIC_SAFETY | ||
200 | } | ||
201 | #endif | ||
202 | |||
203 | eina_shutdown(); | ||
204 | } | ||
205 | END_TEST | ||
206 | |||
207 | |||
208 | |||
209 | START_TEST(eina_ustr_strlen_test) | ||
210 | { | ||
211 | |||
212 | eina_init(); | ||
213 | |||
214 | fail_if(eina_unicode_strlen(STR1) != 8); | ||
215 | fail_if(eina_unicode_strlen(STR2) != 9); | ||
216 | fail_if(eina_unicode_strlen(STR3) != 8); | ||
217 | fail_if(eina_unicode_strlen(STR4) != 1); | ||
218 | fail_if(eina_unicode_strlen(EMPTYSTR) != 0); | ||
219 | |||
220 | #ifdef EINA_SAFETY_CHECKS | ||
221 | { | ||
222 | struct log_ctx ctx; | ||
223 | |||
224 | #define TEST_MAGIC_SAFETY(fn, _msg) \ | ||
225 | ctx.msg = _msg; \ | ||
226 | ctx.fnc = fn; \ | ||
227 | ctx.did = EINA_FALSE | ||
228 | |||
229 | eina_log_print_cb_set(_eina_test_safety_print_cb, &ctx); | ||
230 | |||
231 | #ifdef SHOW_LOG | ||
232 | fprintf(stderr, "you should have a safety check failure below:\n"); | ||
233 | #endif | ||
234 | TEST_MAGIC_SAFETY("eina_unicode_strlen", | ||
235 | "safety check failed: ustr == NULL"); | ||
236 | fail_if(eina_unicode_strlen(NULL)); | ||
237 | fail_unless(ctx.did); | ||
238 | |||
239 | eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); | ||
240 | #undef TEST_MAGIC_SAFETY | ||
241 | } | ||
242 | #endif | ||
243 | |||
244 | eina_shutdown(); | ||
245 | } | ||
246 | END_TEST | ||
247 | |||
248 | START_TEST(eina_unicode_strnlen_test) | ||
249 | { | ||
250 | eina_init(); | ||
251 | |||
252 | /* Strlen style tests*/ | ||
253 | fail_if(eina_unicode_strnlen(STR1,10) != 8); | ||
254 | fail_if(eina_unicode_strnlen(STR2,10) != 9); | ||
255 | fail_if(eina_unicode_strnlen(STR3,10) != 8); | ||
256 | fail_if(eina_unicode_strnlen(STR4,10) != 1); | ||
257 | fail_if(eina_unicode_strnlen(EMPTYSTR,10) != 0); | ||
258 | |||
259 | /* Too short tests */ | ||
260 | fail_if(eina_unicode_strnlen(STR1,3) != 3); | ||
261 | fail_if(eina_unicode_strnlen(STR2,3) != 3); | ||
262 | fail_if(eina_unicode_strnlen(STR3,3) != 3); | ||
263 | fail_if(eina_unicode_strnlen(EMPTYSTR,1) != 0); | ||
264 | |||
265 | #ifdef EINA_SAFETY_CHECKS | ||
266 | { | ||
267 | struct log_ctx ctx; | ||
268 | |||
269 | #define TEST_MAGIC_SAFETY(fn, _msg) \ | ||
270 | ctx.msg = _msg; \ | ||
271 | ctx.fnc = fn; \ | ||
272 | ctx.did = EINA_FALSE | ||
273 | |||
274 | eina_log_print_cb_set(_eina_test_safety_print_cb, &ctx); | ||
275 | |||
276 | #ifdef SHOW_LOG | ||
277 | fprintf(stderr, "you should have a safety check failure below:\n"); | ||
278 | #endif | ||
279 | TEST_MAGIC_SAFETY("eina_unicode_strnlen", | ||
280 | "safety check failed: ustr == NULL"); | ||
281 | fail_if(eina_unicode_strnlen(NULL,0) != 0); | ||
282 | fail_unless(ctx.did); | ||
283 | |||
284 | eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); | ||
285 | #undef TEST_MAGIC_SAFETY | ||
286 | } | ||
287 | #endif | ||
288 | |||
289 | eina_shutdown(); | ||
290 | } | ||
291 | END_TEST | ||
292 | |||
293 | START_TEST(eina_unicode_strdup_test) | ||
294 | { | ||
295 | Eina_Unicode *buf; | ||
296 | |||
297 | eina_init(); | ||
298 | |||
299 | buf = eina_unicode_strdup(STR1); | ||
300 | fail_if(!buf); | ||
301 | fail_if(eina_unicode_strlen(buf) != eina_unicode_strlen(STR1)); | ||
302 | fail_if(eina_unicode_strcmp(buf, STR1)); | ||
303 | free(buf); | ||
304 | |||
305 | buf = eina_unicode_strdup(EMPTYSTR); | ||
306 | fail_if(!buf); | ||
307 | fail_if(buf[0] != 0); | ||
308 | |||
309 | eina_shutdown(); | ||
310 | } | ||
311 | END_TEST | ||
312 | |||
313 | START_TEST(eina_unicode_strstr_test) | ||
314 | { | ||
315 | Eina_Unicode *buf; | ||
316 | Eina_Unicode on[] = { 'O', 'n', 0 }; | ||
317 | |||
318 | eina_init(); | ||
319 | |||
320 | buf = eina_unicode_strstr(STR1,on); | ||
321 | fail_if(!buf); | ||
322 | fail_if(buf != STR1 + 6); | ||
323 | fail_if(eina_unicode_strcmp(buf,on) != 0); | ||
324 | |||
325 | buf = eina_unicode_strstr(STR2,on); | ||
326 | fail_if(buf); | ||
327 | |||
328 | buf = eina_unicode_strstr(EMPTYSTR, on); | ||
329 | fail_if(buf); | ||
330 | |||
331 | buf = eina_unicode_strstr(STR1, EMPTYSTR); | ||
332 | fail_if(!buf); | ||
333 | fail_if(buf != STR1); | ||
334 | |||
335 | eina_shutdown(); | ||
336 | } | ||
337 | END_TEST | ||
338 | |||
339 | START_TEST(eina_unicode_utf8) | ||
340 | { | ||
341 | int ind; | ||
342 | unsigned char ch; | ||
343 | eina_init(); | ||
344 | |||
345 | /* Valid utf-8 cases */ | ||
346 | /* First possible sequence of a certain length */ | ||
347 | ind = 0; | ||
348 | fail_if((eina_unicode_utf8_get_next("\x00", &ind) != 0x00) || | ||
349 | (ind != 0)); | ||
350 | ind = 0; | ||
351 | fail_if((eina_unicode_utf8_get_next("\x01", &ind) != 0x01) || | ||
352 | (ind != 1)); | ||
353 | ind = 0; | ||
354 | fail_if((eina_unicode_utf8_get_next("\xC2\x80", &ind) != 0x80) || | ||
355 | (ind != 2)); | ||
356 | ind = 0; | ||
357 | fail_if((eina_unicode_utf8_get_next("\xE0\xA0\x80", &ind) != 0x800) || | ||
358 | (ind != 3)); | ||
359 | ind = 0; | ||
360 | fail_if((eina_unicode_utf8_get_next("\xF0\x90\x80\x80", &ind) != 0x10000) || | ||
361 | (ind != 4)); | ||
362 | ind = 0; | ||
363 | fail_if((eina_unicode_utf8_get_next("\xF8\x88\x80\x80\x80", &ind) != 0x200000) || (ind != 5)); | ||
364 | ind = 0; | ||
365 | fail_if((eina_unicode_utf8_get_next("\xFC\x84\x80\x80\x80\x80", &ind) != 0x4000000) || (ind != 6)); | ||
366 | |||
367 | /* Last possible sequence of a certain length */ | ||
368 | ind = 0; | ||
369 | fail_if((eina_unicode_utf8_get_next("\x7F", &ind) != 0x7F) || | ||
370 | (ind != 1)); | ||
371 | ind = 0; | ||
372 | fail_if((eina_unicode_utf8_get_next("\xDF\xBF", &ind) != 0x7FF) || | ||
373 | (ind != 2)); | ||
374 | ind = 0; | ||
375 | fail_if((eina_unicode_utf8_get_next("\xEF\xBF\xBF", &ind) != 0xFFFF) || | ||
376 | (ind != 3)); | ||
377 | ind = 0; | ||
378 | fail_if((eina_unicode_utf8_get_next("\xF7\xBF\xBF\xBF", &ind) != 0x1FFFFF) || | ||
379 | (ind != 4)); | ||
380 | ind = 0; | ||
381 | fail_if((eina_unicode_utf8_get_next("\xFB\xBF\xBF\xBF\xBF", &ind) != 0x3FFFFFF) || (ind != 5)); | ||
382 | ind = 0; | ||
383 | fail_if((eina_unicode_utf8_get_next("\xFD\xBF\xBF\xBF\xBF\xBF", &ind) != 0x7FFFFFFF) || (ind != 6)); | ||
384 | |||
385 | /* Other boundary conditions */ | ||
386 | ind = 0; | ||
387 | fail_if((eina_unicode_utf8_get_next("\xED\x9F\xBF", &ind) != 0xD7FF) || | ||
388 | (ind != 3)); | ||
389 | ind = 0; | ||
390 | fail_if((eina_unicode_utf8_get_next("\xEE\x80\x80", &ind) != 0xE000) || | ||
391 | (ind != 3)); | ||
392 | ind = 0; | ||
393 | fail_if((eina_unicode_utf8_get_next("\xEF\xBF\xBD", &ind) != 0xFFFD) || | ||
394 | (ind != 3)); | ||
395 | ind = 0; | ||
396 | fail_if((eina_unicode_utf8_get_next("\xF4\x8F\xBF\xBF", &ind) != 0x10FFFF) || | ||
397 | (ind != 4)); | ||
398 | ind = 0; | ||
399 | fail_if((eina_unicode_utf8_get_next("\xF4\x90\x80\x80", &ind) != 0x110000) || | ||
400 | (ind != 4)); | ||
401 | |||
402 | /* Error cases */ | ||
403 | /* Standalone continuation bytes */ | ||
404 | ind = 0; | ||
405 | fail_if((eina_unicode_utf8_get_next("\x80", &ind) != 0xDC80) || | ||
406 | (ind != 1)); | ||
407 | ind = 0; | ||
408 | fail_if((eina_unicode_utf8_get_next("\xBF", &ind) != 0xDCBF) || | ||
409 | (ind != 1)); | ||
410 | ind = 0; | ||
411 | fail_if((eina_unicode_utf8_get_next("\x80\xBF", &ind) != 0xDC80) || | ||
412 | (ind != 1)); | ||
413 | ind = 0; | ||
414 | fail_if((eina_unicode_utf8_get_next("\xBF\x80", &ind) != 0xDCBF) || | ||
415 | (ind != 1)); | ||
416 | /* All possible continuation bytes */ | ||
417 | for (ch = 0x80 ; ch <= 0xBF ; ch++) | ||
418 | { | ||
419 | char buf[] = {ch, 0}; | ||
420 | ind = 0; | ||
421 | fail_if((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || | ||
422 | (ind != 1)); | ||
423 | } | ||
424 | |||
425 | /* Isolated starting sequences */ | ||
426 | #define _FIRST_SEQUENCES(start, end) \ | ||
427 | do \ | ||
428 | { \ | ||
429 | int i; \ | ||
430 | char *buf = alloca(((end - start + 1) * 2) + 1); \ | ||
431 | for (i = 0, ch = start ; ch <= end ; i++, ch++) \ | ||
432 | { \ | ||
433 | buf[i * 2] = ch; \ | ||
434 | buf[(i * 2) + 1] = ' '; \ | ||
435 | } \ | ||
436 | ind = 0; \ | ||
437 | for (i = 0, ch = start ; ch <= end ; ch++) \ | ||
438 | { \ | ||
439 | fail_if((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || \ | ||
440 | (ind != ++i)); \ | ||
441 | fail_if((eina_unicode_utf8_get_next(buf, &ind) != 0x20) || \ | ||
442 | (ind != ++i)); \ | ||
443 | } \ | ||
444 | } \ | ||
445 | while (0) | ||
446 | /* all first bytes of 2-byte sequences separated by spaces. */ | ||
447 | _FIRST_SEQUENCES(0xC0, 0xDF); | ||
448 | /* all first bytes of 3-byte sequences separated by spaces. */ | ||
449 | _FIRST_SEQUENCES(0xE0, 0xEF); | ||
450 | /* all first bytes of 4-byte sequences separated by spaces. */ | ||
451 | _FIRST_SEQUENCES(0xF0, 0xF7); | ||
452 | /* all first bytes of 5-byte sequences separated by spaces. */ | ||
453 | _FIRST_SEQUENCES(0xF8, 0xFB); | ||
454 | /* all first bytes of 6-byte sequences separated by spaces. */ | ||
455 | _FIRST_SEQUENCES(0xFC, 0xFD); | ||
456 | |||
457 | /* Incomplete sequences first means the first utf8 char, len means | ||
458 | * the correct length */ | ||
459 | #define _INCOMPLETE_SEQUENCES(first, conti, len) \ | ||
460 | do \ | ||
461 | { \ | ||
462 | int i, j; \ | ||
463 | char *buf = alloca(len + 1); \ | ||
464 | i = 0; \ | ||
465 | buf[i++] = first; \ | ||
466 | for ( ; i < len ; i++) \ | ||
467 | { \ | ||
468 | Eina_Unicode val; \ | ||
469 | for (j = 1 ; j < i ; j++) \ | ||
470 | { \ | ||
471 | buf[j] = conti; \ | ||
472 | } \ | ||
473 | buf[j] = 0; \ | ||
474 | ind = 0; \ | ||
475 | fail_if( \ | ||
476 | (eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | first))); \ | ||
477 | while ((val = eina_unicode_utf8_get_next(buf, &ind))) \ | ||
478 | { \ | ||
479 | fail_if(val != (0xDC00 | conti)); \ | ||
480 | } \ | ||
481 | fail_if(ind != i); \ | ||
482 | } \ | ||
483 | } \ | ||
484 | while (0) | ||
485 | |||
486 | /* Sequences with missing continuation */ | ||
487 | _INCOMPLETE_SEQUENCES(0xC0, 0x81, 2); | ||
488 | _INCOMPLETE_SEQUENCES(0xDF, 0xBF, 2); | ||
489 | _INCOMPLETE_SEQUENCES(0xE0, 0x81, 3); | ||
490 | _INCOMPLETE_SEQUENCES(0xEF, 0xBF, 3); | ||
491 | _INCOMPLETE_SEQUENCES(0xF0, 0x81, 4); | ||
492 | _INCOMPLETE_SEQUENCES(0xF7, 0xBF, 4); | ||
493 | _INCOMPLETE_SEQUENCES(0xF8, 0x81, 5); | ||
494 | _INCOMPLETE_SEQUENCES(0xFB, 0xBF, 5); | ||
495 | _INCOMPLETE_SEQUENCES(0xFC, 0x81, 6); | ||
496 | _INCOMPLETE_SEQUENCES(0xFD, 0xBF, 6); | ||
497 | |||
498 | /* Impossible bytes */ | ||
499 | ind = 0; | ||
500 | fail_if((eina_unicode_utf8_get_next("\xFE", &ind) != 0xDCFE) || | ||
501 | (ind != 1)); | ||
502 | ind = 0; | ||
503 | fail_if((eina_unicode_utf8_get_next("\xFF", &ind) != 0xDCFF) || | ||
504 | (ind != 1)); | ||
505 | |||
506 | /* Overlong sequences */ | ||
507 | ind = 0; | ||
508 | fail_if((eina_unicode_utf8_get_next("\xC0\xAF", &ind) != 0xDCC0) || | ||
509 | (ind != 1)); | ||
510 | ind = 0; | ||
511 | fail_if((eina_unicode_utf8_get_next("\xE0\x80\xAF", &ind) != 0xDCE0) || | ||
512 | (ind != 1)); | ||
513 | ind = 0; | ||
514 | fail_if((eina_unicode_utf8_get_next("\xF0\x80\x80\xAF", &ind) != 0xDCF0) || | ||
515 | (ind != 1)); | ||
516 | ind = 0; | ||
517 | fail_if((eina_unicode_utf8_get_next("\xF8\x80\x80\x80\xAF", &ind) != 0xDCF8) || | ||
518 | (ind != 1)); | ||
519 | ind = 0; | ||
520 | fail_if((eina_unicode_utf8_get_next("\xFC\x80\x80\x80\x80\xAF", &ind) != 0xDCFC) || | ||
521 | (ind != 1)); | ||
522 | |||
523 | /* Maximum overlong sequences */ | ||
524 | ind = 0; | ||
525 | fail_if((eina_unicode_utf8_get_next("\xC1\xBF", &ind) != 0xDCC1) || | ||
526 | (ind != 1)); | ||
527 | ind = 0; | ||
528 | fail_if((eina_unicode_utf8_get_next("\xE0\x9F\xBF", &ind) != 0xDCE0) || | ||
529 | (ind != 1)); | ||
530 | ind = 0; | ||
531 | fail_if((eina_unicode_utf8_get_next("\xF0\x8F\xBF\xBF", &ind) != 0xDCF0) || | ||
532 | (ind != 1)); | ||
533 | ind = 0; | ||
534 | fail_if((eina_unicode_utf8_get_next("\xF8\x87\xBF\xBF\xBF", &ind) != 0xDCF8) || | ||
535 | (ind != 1)); | ||
536 | ind = 0; | ||
537 | fail_if((eina_unicode_utf8_get_next("\xFC\x83\xBF\xBF\xBF\xBF", &ind) != 0xDCFC) || | ||
538 | (ind != 1)); | ||
539 | /* Add some more error cases here */ | ||
540 | |||
541 | /* Just to cover prev/len. General utf-8 parsing was covered above */ | ||
542 | fail_if(eina_unicode_utf8_get_len("\xF4\x90\x80\x80\xF4\x8F\xBF\xBF") != 2); | ||
543 | ind = 0; | ||
544 | fail_if((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0xD7FF) || | ||
545 | (ind != 0)); | ||
546 | ind = 3; | ||
547 | fail_if((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0x00) || | ||
548 | (ind != 0)); | ||
549 | |||
550 | eina_shutdown(); | ||
551 | } | ||
552 | END_TEST | ||
553 | |||
554 | START_TEST(eina_unicode_utf8_conversion) | ||
555 | { | ||
556 | Eina_Unicode uni_in[] = {0x5D0, 0xFDF6, 0xDC80, 0x1F459, 0x3FFFFFF, | ||
557 | 0x7FFFFFFF, 'a', 'b', 'c', 0}; | ||
558 | Eina_Unicode *uni_out; | ||
559 | char c_in[] = "\xD7\x90""\xEF\xB7\xB6""\x80""\xF0\x9F\x91\x99" | ||
560 | "\xFB\xBF\xBF\xBF\xBF""\xFD\xBF\xBF\xBF\xBF\xBF""abc"; | ||
561 | char *c_out; | ||
562 | int len; | ||
563 | |||
564 | eina_init(); | ||
565 | |||
566 | uni_out = eina_unicode_utf8_to_unicode(c_in, &len); | ||
567 | fail_if((len != 9) || eina_unicode_strcmp(uni_in, uni_out)); | ||
568 | free(uni_out); | ||
569 | |||
570 | c_out = eina_unicode_unicode_to_utf8(uni_in, &len); | ||
571 | fail_if((len != 24) || strcmp(c_in, c_out)); | ||
572 | free(c_out); | ||
573 | |||
574 | eina_shutdown(); | ||
575 | } | ||
576 | END_TEST | ||
577 | |||
578 | void | ||
579 | eina_test_ustr(TCase *tc) | ||
580 | { | ||
581 | printf("ustr test\n"); | ||
582 | tcase_add_test(tc,eina_unicode_strcmp_test); | ||
583 | tcase_add_test(tc,eina_unicode_strcpy_test); | ||
584 | tcase_add_test(tc,eina_unicode_strncpy_test); | ||
585 | tcase_add_test(tc,eina_ustr_strlen_test); | ||
586 | tcase_add_test(tc,eina_unicode_strnlen_test); | ||
587 | tcase_add_test(tc,eina_unicode_strdup_test); | ||
588 | tcase_add_test(tc,eina_unicode_strstr_test); | ||
589 | tcase_add_test(tc,eina_unicode_utf8); | ||
590 | tcase_add_test(tc,eina_unicode_utf8_conversion); | ||
591 | |||
592 | } | ||
593 | |||