deps/libretro-common/test/string/test_stdstring.c

   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 }