1 /* Copyright (C) 2021 The RetroArch team
3 * ---------------------------------------------------------------------------------------
4 * The following license statement only applies to this file (test_stdstring.c).
5 * ---------------------------------------------------------------------------------------
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:
13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
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.
28 #include <string/stdstring.h>
29 #include <encodings/utf.h>
31 #define SUITE_NAME "stdstring"
33 START_TEST (test_string_filter)
35 char test1[] = "foo bar some string";
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, ""));
45 START_TEST (test_string_replace)
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"));
54 START_TEST (test_string_case)
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[]_"));
64 START_TEST (test_string_char_classify)
66 ck_assert(ISSPACE(' '));
67 ck_assert(ISSPACE('\n'));
68 ck_assert(ISSPACE('\r'));
69 ck_assert(ISSPACE('\t'));
70 ck_assert(!ISSPACE('a'));
72 ck_assert(ISALPHA('a'));
73 ck_assert(ISALPHA('Z'));
74 ck_assert(!ISALPHA('5'));
76 ck_assert(ISALNUM('a'));
77 ck_assert(ISALNUM('Z'));
78 ck_assert(ISALNUM('5'));
82 START_TEST (test_string_num_conv)
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));
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));
101 START_TEST (test_string_tokenizer)
103 char *testinput = "@@1@@2@@3@@@@9@@@";
104 char **ptr = &testinput;
106 token = string_tokenize(ptr, "@@");
107 ck_assert(token != NULL);
108 ck_assert(!strcmp(token, ""));
110 token = string_tokenize(ptr, "@@");
111 ck_assert(token != NULL);
112 ck_assert(!strcmp(token, "1"));
114 token = string_tokenize(ptr, "@@");
115 ck_assert(token != NULL);
116 ck_assert(!strcmp(token, "2"));
118 token = string_tokenize(ptr, "@@");
119 ck_assert(token != NULL);
120 ck_assert(!strcmp(token, "3"));
122 token = string_tokenize(ptr, "@@");
123 ck_assert(token != NULL);
124 ck_assert(!strcmp(token, ""));
126 token = string_tokenize(ptr, "@@");
127 ck_assert(token != NULL);
128 ck_assert(!strcmp(token, "9"));
130 token = string_tokenize(ptr, "@@");
131 ck_assert(token != NULL);
132 ck_assert(!strcmp(token, "@"));
134 token = string_tokenize(ptr, "@@");
135 ck_assert(token == NULL);
139 START_TEST (test_string_replacesubstr)
141 char *res = string_replace_substring("foobaarhellowooorldtest", "oo", "ooo");
142 ck_assert(res != NULL);
143 ck_assert(!strcmp(res, "fooobaarhellowoooorldtest"));
148 START_TEST (test_string_trim)
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"));
162 START_TEST (test_string_comparison)
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));
171 START_TEST (test_word_wrap)
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"
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.");
199 word_wrap(output, sizeof(output), testtxt, strlen(testtxt), 40, 100, 10);
200 ck_assert(!strcmp(output, expected));
204 START_TEST (test_strlcpy)
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));
214 START_TEST (test_strlcat)
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));
226 START_TEST (test_strldup)
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);
240 START_TEST (test_utf8_conv_utf32)
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]);
256 START_TEST (test_utf8_util)
258 const char *test1 = "aæ⠻จ𠀤";
259 const char **tptr = &test1;
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));
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));
271 //ck_assert_uint_eq(1, utf8cpy(out, 64, test1, 1));
275 START_TEST (test_utf16_conv)
277 const uint16_t test1[] = {0x0061, 0x00e6, 0x283b, 0x0e08, 0xd840, 0xdc24};
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));
286 Suite *create_suite(void)
288 Suite *s = suite_create(SUITE_NAME);
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);
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);
320 return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;