Commit | Line | Data |
---|---|---|
3719602c PC |
1 | /* Copyright (C) 2021 The RetroArch team |
2 | * | |
3 | * --------------------------------------------------------------------------------------- | |
4 | * The following license statement only applies to this file (test_stdstring.c). | |
5 | * --------------------------------------------------------------------------------------- | |
6 | * | |
7 | * Permission is hereby granted, free of charge, | |
8 | * to any person obtaining a copy of this software and associated documentation files (the "Software"), | |
9 | * to deal in the Software without restriction, including without limitation the rights to | |
10 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, | |
11 | * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, | |
16 | * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
18 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
19 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
21 | */ | |
22 | ||
23 | #include <check.h> | |
24 | #include <stdarg.h> | |
25 | #include <stdlib.h> | |
26 | #include <stdio.h> | |
27 | ||
28 | #include <string/stdstring.h> | |
29 | #include <encodings/utf.h> | |
30 | ||
31 | #define SUITE_NAME "stdstring" | |
32 | ||
33 | START_TEST (test_string_filter) | |
34 | { | |
35 | char test1[] = "foo bar some string"; | |
36 | char test2[] = ""; | |
37 | string_remove_all_chars(test1, 's'); | |
38 | string_remove_all_chars(test2, '0'); | |
39 | string_remove_all_chars(NULL, 'a'); | |
40 | ck_assert(!strcmp(test1, "foo bar ome tring")); | |
41 | ck_assert(!strcmp(test2, "")); | |
42 | } | |
43 | END_TEST | |
44 | ||
45 | START_TEST (test_string_replace) | |
46 | { | |
47 | char test1[] = "foo bar some string"; | |
48 | string_replace_all_chars(test1, 's', 'S'); | |
49 | string_replace_all_chars(NULL, 'a', 'A'); | |
50 | ck_assert(!strcmp(test1, "foo bar Some String")); | |
51 | } | |
52 | END_TEST | |
53 | ||
54 | START_TEST (test_string_case) | |
55 | { | |
56 | char test1[] = "foo"; | |
57 | char test2[] = "01foOo[]_"; | |
58 | ck_assert(!strcmp(string_to_upper(test1), "FOO")); | |
59 | ck_assert(!strcmp(string_to_upper(test2), "01FOOO[]_")); | |
60 | ck_assert(!strcmp(string_to_lower(test2), "01fooo[]_")); | |
61 | } | |
62 | END_TEST | |
63 | ||
64 | START_TEST (test_string_char_classify) | |
65 | { | |
66 | ck_assert(ISSPACE(' ')); | |
67 | ck_assert(ISSPACE('\n')); | |
68 | ck_assert(ISSPACE('\r')); | |
69 | ck_assert(ISSPACE('\t')); | |
70 | ck_assert(!ISSPACE('a')); | |
71 | ||
72 | ck_assert(ISALPHA('a')); | |
73 | ck_assert(ISALPHA('Z')); | |
74 | ck_assert(!ISALPHA('5')); | |
75 | ||
76 | ck_assert(ISALNUM('a')); | |
77 | ck_assert(ISALNUM('Z')); | |
78 | ck_assert(ISALNUM('5')); | |
79 | } | |
80 | END_TEST | |
81 | ||
82 | START_TEST (test_string_num_conv) | |
83 | { | |
84 | ck_assert_uint_eq(3, string_to_unsigned("3")); | |
85 | ck_assert_uint_eq(2147483647, string_to_unsigned("2147483647")); | |
86 | ck_assert_uint_eq(0, string_to_unsigned("foo")); | |
87 | ck_assert_uint_eq(0, string_to_unsigned("-1")); | |
88 | ck_assert_uint_eq(0, string_to_unsigned(NULL)); | |
89 | ||
90 | ck_assert_uint_eq(10, string_hex_to_unsigned("0xa")); | |
91 | ck_assert_uint_eq(10, string_hex_to_unsigned("a")); | |
92 | ck_assert_uint_eq(255, string_hex_to_unsigned("FF")); | |
93 | ck_assert_uint_eq(255, string_hex_to_unsigned("0xff")); | |
94 | ck_assert_uint_eq(0, string_hex_to_unsigned("0xfzzf")); | |
95 | ck_assert_uint_eq(0, string_hex_to_unsigned("0x")); | |
96 | ck_assert_uint_eq(0, string_hex_to_unsigned("0xx")); | |
97 | ck_assert_uint_eq(0, string_hex_to_unsigned(NULL)); | |
98 | } | |
99 | END_TEST | |
100 | ||
101 | START_TEST (test_string_tokenizer) | |
102 | { | |
103 | char *testinput = "@@1@@2@@3@@@@9@@@"; | |
104 | char **ptr = &testinput; | |
105 | char *token = NULL; | |
106 | token = string_tokenize(ptr, "@@"); | |
107 | ck_assert(token != NULL); | |
108 | ck_assert(!strcmp(token, "")); | |
109 | free(token); | |
110 | token = string_tokenize(ptr, "@@"); | |
111 | ck_assert(token != NULL); | |
112 | ck_assert(!strcmp(token, "1")); | |
113 | free(token); | |
114 | token = string_tokenize(ptr, "@@"); | |
115 | ck_assert(token != NULL); | |
116 | ck_assert(!strcmp(token, "2")); | |
117 | free(token); | |
118 | token = string_tokenize(ptr, "@@"); | |
119 | ck_assert(token != NULL); | |
120 | ck_assert(!strcmp(token, "3")); | |
121 | free(token); | |
122 | token = string_tokenize(ptr, "@@"); | |
123 | ck_assert(token != NULL); | |
124 | ck_assert(!strcmp(token, "")); | |
125 | free(token); | |
126 | token = string_tokenize(ptr, "@@"); | |
127 | ck_assert(token != NULL); | |
128 | ck_assert(!strcmp(token, "9")); | |
129 | free(token); | |
130 | token = string_tokenize(ptr, "@@"); | |
131 | ck_assert(token != NULL); | |
132 | ck_assert(!strcmp(token, "@")); | |
133 | free(token); | |
134 | token = string_tokenize(ptr, "@@"); | |
135 | ck_assert(token == NULL); | |
136 | } | |
137 | END_TEST | |
138 | ||
139 | START_TEST (test_string_replacesubstr) | |
140 | { | |
141 | char *res = string_replace_substring("foobaarhellowooorldtest", "oo", "ooo"); | |
142 | ck_assert(res != NULL); | |
143 | ck_assert(!strcmp(res, "fooobaarhellowoooorldtest")); | |
144 | free(res); | |
145 | } | |
146 | END_TEST | |
147 | ||
148 | START_TEST (test_string_trim) | |
149 | { | |
150 | char test1[] = "\t \t\nhey there \n \n"; | |
151 | char test2[] = "\t \t\nhey there \n \n"; | |
152 | char test3[] = "\t \t\nhey there \n \n"; | |
153 | ck_assert(string_trim_whitespace_left(test1) == (char*)test1); | |
154 | ck_assert(!strcmp(test1, "hey there \n \n")); | |
155 | ck_assert(string_trim_whitespace_right(test2) == (char*)test2); | |
156 | ck_assert(!strcmp(test2, "\t \t\nhey there")); | |
157 | ck_assert(string_trim_whitespace(test3) == (char*)test3); | |
158 | ck_assert(!strcmp(test3, "hey there")); | |
159 | } | |
160 | END_TEST | |
161 | ||
162 | START_TEST (test_string_comparison) | |
163 | { | |
164 | ck_assert(string_is_not_equal_fast("foo", "bar", 3)); | |
165 | ck_assert(string_is_equal_fast("foo2", "foo2", 4)); | |
166 | ck_assert(!string_is_equal_fast("foo1", "foo2", 4)); | |
167 | ck_assert(string_is_equal_fast("foo1", "foo2", 3)); | |
168 | } | |
169 | END_TEST | |
170 | ||
171 | START_TEST (test_word_wrap) | |
172 | { | |
173 | const char *testtxt = ( | |
174 | "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam nec " | |
175 | "enim quis orci euismod efficitur at nec arcu. Vivamus imperdiet est " | |
176 | "feugiat massa rhoncus porttitor at vitae ante. Nunc a orci vel ipsum " | |
177 | "tempor posuere sed a lacus. Ut erat odio, ultrices vitae iaculis " | |
178 | "fringilla, iaculis ut eros.\nSed facilisis viverra lectus et " | |
179 | "ullamcorper. Aenean risus ex, ornare eget scelerisque ac, imperdiet eu " | |
180 | "ipsum. Morbi pellentesque erat metus, sit amet aliquet libero rutrum " | |
181 | "et. Integer non ullamcorper tellus."); | |
182 | const char *expected = ( | |
183 | "Lorem ipsum dolor sit amet, consectetur\n" | |
184 | "adipiscing elit. Nam nec enim quis orci\n" | |
185 | "euismod efficitur at nec arcu. Vivamus\n" | |
186 | "imperdiet est feugiat massa rhoncus\n" | |
187 | "porttitor at vitae ante. Nunc a orci\n" | |
188 | "vel ipsum tempor posuere sed a lacus.\n" | |
189 | "Ut erat odio, ultrices vitae iaculis\n" | |
190 | "fringilla, iaculis ut eros.\n" | |
191 | "Sed facilisis viverra lectus et\n" | |
192 | "ullamcorper. " | |
193 | "Aenean risus ex, ornare eget scelerisque ac, imperdiet eu ipsum. Morbi " | |
194 | "pellentesque erat metus, sit amet aliquet libero rutrum et. Integer " | |
195 | "non ullamcorper tellus."); | |
196 | ||
197 | char output[1024]; | |
198 | ||
199 | word_wrap(output, sizeof(output), testtxt, strlen(testtxt), 40, 100, 10); | |
200 | ck_assert(!strcmp(output, expected)); | |
201 | } | |
202 | END_TEST | |
203 | ||
204 | START_TEST (test_strlcpy) | |
205 | { | |
206 | char buf1[8]; | |
207 | ck_assert_uint_eq(3, strlcpy(buf1, "foo", sizeof(buf1))); | |
208 | ck_assert(!memcmp(buf1, "foo", 4)); | |
209 | ck_assert_uint_eq(11, strlcpy(buf1, "foo12345678", sizeof(buf1))); | |
210 | ck_assert(!memcmp(buf1, "foo1234", 8)); | |
211 | } | |
212 | END_TEST | |
213 | ||
214 | START_TEST (test_strlcat) | |
215 | { | |
216 | char buf1[8]; | |
217 | buf1[0] = 'f'; | |
218 | buf1[1] = '\0'; | |
219 | ck_assert_uint_eq(10, strlcat(buf1, "ooooooooo", sizeof(buf1))); | |
220 | ck_assert(!memcmp(buf1, "foooooo\0", 8)); | |
221 | ck_assert_uint_eq(13, strlcat(buf1, "123456", sizeof(buf1))); | |
222 | ck_assert(!memcmp(buf1, "foooooo\0", 8)); | |
223 | } | |
224 | END_TEST | |
225 | ||
226 | START_TEST (test_strldup) | |
227 | { | |
228 | char buf1[8] = "foo"; | |
229 | char *tv1 = strldup(buf1, 16); | |
230 | char *tv2 = strldup(buf1, 2); | |
231 | ck_assert(tv1 != (char*)buf1); | |
232 | ck_assert(tv2 != (char*)buf1); | |
233 | ck_assert_uint_eq(strlen(tv2), 1); | |
234 | ck_assert(tv2[0] == 'f' && tv2[1] == 0); | |
235 | free(tv1); | |
236 | free(tv2); | |
237 | } | |
238 | END_TEST | |
239 | ||
240 | START_TEST (test_utf8_conv_utf32) | |
241 | { | |
242 | uint32_t output[12]; | |
243 | const char test1[] = "aæ⠻จйγチℝ\xff"; | |
244 | ck_assert_uint_eq(8, utf8_conv_utf32(output, 12, test1, strlen(test1))); | |
245 | ck_assert_uint_eq(97, output[0]); | |
246 | ck_assert_uint_eq(230, output[1]); | |
247 | ck_assert_uint_eq(10299, output[2]); | |
248 | ck_assert_uint_eq(3592, output[3]); | |
249 | ck_assert_uint_eq(1081, output[4]); | |
250 | ck_assert_uint_eq(947, output[5]); | |
251 | ck_assert_uint_eq(12481, output[6]); | |
252 | ck_assert_uint_eq(8477, output[7]); | |
253 | } | |
254 | END_TEST | |
255 | ||
256 | START_TEST (test_utf8_util) | |
257 | { | |
258 | const char *test1 = "aæ⠻จ𠀤"; | |
259 | const char **tptr = &test1; | |
260 | char out[64]; | |
261 | ck_assert_uint_eq(utf8len(test1), 5); | |
262 | ck_assert_uint_eq(utf8len(NULL), 0); | |
263 | ck_assert(&test1[1 + 2 + 3] == utf8skip(test1, 3)); | |
264 | ||
265 | ck_assert_uint_eq(97, utf8_walk(tptr)); | |
266 | ck_assert_uint_eq(230, utf8_walk(tptr)); | |
267 | ck_assert_uint_eq(10299, utf8_walk(tptr)); | |
268 | ck_assert_uint_eq(3592, utf8_walk(tptr)); | |
269 | ck_assert_uint_eq(131108, utf8_walk(tptr)); | |
270 | ||
271 | //ck_assert_uint_eq(1, utf8cpy(out, 64, test1, 1)); | |
272 | } | |
273 | END_TEST | |
274 | ||
275 | START_TEST (test_utf16_conv) | |
276 | { | |
277 | const uint16_t test1[] = {0x0061, 0x00e6, 0x283b, 0x0e08, 0xd840, 0xdc24}; | |
278 | char out[64]; | |
279 | size_t outlen = sizeof(out); | |
280 | ck_assert(utf16_conv_utf8((uint8_t*)out, &outlen, test1, sizeof(test1) / 2)); | |
281 | ck_assert_uint_eq(outlen, 13); | |
282 | ck_assert(!memcmp(out, "aæ⠻จ𠀤", 13)); | |
283 | } | |
284 | END_TEST | |
285 | ||
286 | Suite *create_suite(void) | |
287 | { | |
288 | Suite *s = suite_create(SUITE_NAME); | |
289 | ||
290 | TCase *tc_core = tcase_create("Core"); | |
291 | tcase_add_test(tc_core, test_string_comparison); | |
292 | tcase_add_test(tc_core, test_string_num_conv); | |
293 | tcase_add_test(tc_core, test_string_char_classify); | |
294 | tcase_add_test(tc_core, test_string_case); | |
295 | tcase_add_test(tc_core, test_string_filter); | |
296 | tcase_add_test(tc_core, test_string_replace); | |
297 | tcase_add_test(tc_core, test_string_tokenizer); | |
298 | tcase_add_test(tc_core, test_string_trim); | |
299 | tcase_add_test(tc_core, test_string_replacesubstr); | |
300 | tcase_add_test(tc_core, test_word_wrap); | |
301 | tcase_add_test(tc_core, test_strlcpy); | |
302 | tcase_add_test(tc_core, test_strlcat); | |
303 | tcase_add_test(tc_core, test_strldup); | |
304 | tcase_add_test(tc_core, test_utf8_conv_utf32); | |
305 | tcase_add_test(tc_core, test_utf16_conv); | |
306 | tcase_add_test(tc_core, test_utf8_util); | |
307 | suite_add_tcase(s, tc_core); | |
308 | ||
309 | return s; | |
310 | } | |
311 | ||
312 | int main(void) | |
313 | { | |
314 | int num_fail; | |
315 | Suite *s = create_suite(); | |
316 | SRunner *sr = srunner_create(s); | |
317 | srunner_run_all(sr, CK_NORMAL); | |
318 | num_fail = srunner_ntests_failed(sr); | |
319 | srunner_free(sr); | |
320 | return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; | |
321 | } |