dlls/ucrtbase/tests/string.c

   1 /*
   2  * Copyright 2015 Martin Storsjo
   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; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <errno.h>
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include <wchar.h>
  23 #include <stdio.h>
  24 #include <locale.h>
  25 #include <mbctype.h>
  26 #include <mbstring.h>
  27
  28 #include <windef.h>
  29 #include <winbase.h>
  30 #include "wine/test.h"
  31
  32 #include <math.h>
  33
  34 #define DEFINE_EXPECT(func) \
  35     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  36
  37 #define SET_EXPECT(func) \
  38     expect_ ## func = TRUE
  39
  40 #define CHECK_EXPECT2(func) \
  41     do { \
  42         ok(expect_ ##func, "unexpected call " #func "\n"); \
  43         called_ ## func = TRUE; \
  44     }while(0)
  45
  46 #define CHECK_EXPECT(func) \
  47     do { \
  48         CHECK_EXPECT2(func); \
  49         expect_ ## func = FALSE; \
  50     }while(0)
  51
  52 #define CHECK_CALLED(func) \
  53     do { \
  54         ok(called_ ## func, "expected " #func "\n"); \
  55         expect_ ## func = called_ ## func = FALSE; \
  56     }while(0)
  57
  58 DEFINE_EXPECT(invalid_parameter_handler);
  59
  60 static void __cdecl test_invalid_parameter_handler(const wchar_t *expression,
  61         const wchar_t *function, const wchar_t *file,
  62         unsigned line, uintptr_t arg)
  63 {
  64     CHECK_EXPECT(invalid_parameter_handler);
  65     ok(expression == NULL, "expression is not NULL\n");
  66     ok(function == NULL, "function is not NULL\n");
  67     ok(file == NULL, "file is not NULL\n");
  68     ok(line == 0, "line = %u\n", line);
  69     ok(arg == 0, "arg = %lx\n", (UINT_PTR)arg);
  70 }
  71
  72 _ACRTIMP int __cdecl _o_tolower(int);
  73 _ACRTIMP int __cdecl _o_toupper(int);
  74
  75 static BOOL local_isnan(double d)
  76 {
  77     return d != d;
  78 }
  79
  80 #define test_strtod_str_errno(string, value, length, err) _test_strtod_str(__LINE__, string, value, length, err)
  81 #define test_strtod_str(string, value, length) _test_strtod_str(__LINE__, string, value, length, 0)
  82 static void _test_strtod_str(int line, const char* string, double value, int length, int err)
  83 {
  84     char *end;
  85     double d;
  86     errno = 0xdeadbeef;
  87     d = strtod(string, &end);
  88     if(!err)
  89         ok_(__FILE__, line)(errno == 0xdeadbeef, "errno = %d\n", errno);
  90     else
  91         ok_(__FILE__, line)(errno == err, "errno = %d\n", errno);
  92     if (local_isnan(value))
  93         ok_(__FILE__, line)(local_isnan(d), "d = %.16le (\"%s\")\n", d, string);
  94     else
  95         ok_(__FILE__, line)(d == value, "d = %.16le (\"%s\")\n", d, string);
  96     ok_(__FILE__, line)(end == string + length, "incorrect end (%d, \"%s\")\n", (int)(end - string), string);
  97 }
  98
  99 static void test_strtod(void)
 100 {
 101     test_strtod_str("infinity", INFINITY, 8);
 102     test_strtod_str("INFINITY", INFINITY, 8);
 103     test_strtod_str("InFiNiTy", INFINITY, 8);
 104     test_strtod_str("INF", INFINITY, 3);
 105     test_strtod_str("-inf", -INFINITY, 4);
 106     test_strtod_str("inf42", INFINITY, 3);
 107     test_strtod_str("inffoo", INFINITY, 3);
 108     test_strtod_str("infini", INFINITY, 3);
 109     test_strtod_str("input", 0, 0);
 110     test_strtod_str("-input", 0, 0);
 111     test_strtod_str_errno("1.7976931348623159e+308", INFINITY, 23, ERANGE);
 112     test_strtod_str_errno("-1.7976931348623159e+308", -INFINITY, 24, ERANGE);
 113
 114     test_strtod_str("NAN", NAN, 3);
 115     test_strtod_str("nan", NAN, 3);
 116     test_strtod_str("NaN", NAN, 3);
 117
 118     test_strtod_str("0x42", 66, 4);
 119     test_strtod_str("0X42", 66, 4);
 120     test_strtod_str("-0x42", -66, 5);
 121     test_strtod_str("0x1p1", 2, 5);
 122     test_strtod_str("0x1P1", 2, 5);
 123     test_strtod_str("0x1p+1", 2, 6);
 124     test_strtod_str("0x2p-1", 1, 6);
 125     test_strtod_str("0xA", 10, 3);
 126     test_strtod_str("0xa", 10, 3);
 127     test_strtod_str("0xABCDEF", 11259375, 8);
 128     test_strtod_str("0Xabcdef", 11259375, 8);
 129
 130     test_strtod_str("0x1.1", 1.0625, 5);
 131     test_strtod_str("0x1.1p1", 2.125, 7);
 132     test_strtod_str("0x1.A", 1.625, 5);
 133     test_strtod_str("0x1p1a", 2, 5);
 134     test_strtod_str("0xp3", 0, 1);
 135     test_strtod_str("0x.", 0, 1);
 136     test_strtod_str("0x.8", 0.5, 4);
 137     test_strtod_str("0x.8p", 0.5, 4);
 138     test_strtod_str("0x0p10000000000000000000000000", 0, 30);
 139     test_strtod_str("0x1p-1026", 1.3906711615670009e-309, 9);
 140
 141     test_strtod_str("0x1ffffffffffffe.80000000000000000000", 9007199254740990.0, 37);
 142     test_strtod_str("0x1ffffffffffffe.80000000000000000001", 9007199254740991.0, 37);
 143     test_strtod_str("0x1fffffffffffff.80000000000000000000", 9007199254740992.0, 37);
 144     test_strtod_str("0x1fffffffffffff.80000000000000000001", 9007199254740992.0, 37);
 145
 146     test_strtod_str("4.0621786324484881721115322e-53", 4.0621786324484881721115322e-53, 31);
 147     test_strtod_str("1.8905590910042396899370942", 1.8905590910042396899370942, 27);
 148     test_strtod_str("1.7976931348623158e+308", 1.7976931348623158e+308, 23);
 149     test_strtod_str("2.2250738585072014e-308", 2.2250738585072014e-308, 23);
 150     test_strtod_str("4.9406564584124654e-324", 4.9406564584124654e-324, 23);
 151 }
 152
 153 static void test__memicmp(void)
 154 {
 155     static const char *s1 = "abc";
 156     static const char *s2 = "aBd";
 157     int ret;
 158
 159     ret = _memicmp(NULL, NULL, 0);
 160     ok(!ret, "got %d\n", ret);
 161
 162     SET_EXPECT(invalid_parameter_handler);
 163     errno = 0xdeadbeef;
 164     ret = _memicmp(NULL, NULL, 1);
 165     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 166     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 167     CHECK_CALLED(invalid_parameter_handler);
 168
 169     SET_EXPECT(invalid_parameter_handler);
 170     errno = 0xdeadbeef;
 171     ret = _memicmp(s1, NULL, 1);
 172     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 173     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 174     CHECK_CALLED(invalid_parameter_handler);
 175
 176     SET_EXPECT(invalid_parameter_handler);
 177     errno = 0xdeadbeef;
 178     ret = _memicmp(NULL, s2, 1);
 179     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 180     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 181     CHECK_CALLED(invalid_parameter_handler);
 182
 183     ret = _memicmp(s1, s2, 2);
 184     ok(!ret, "got %d\n", ret);
 185
 186     ret = _memicmp(s1, s2, 3);
 187     ok(ret == -1, "got %d\n", ret);
 188 }
 189
 190 static void test__memicmp_l(void)
 191 {
 192     static const char *s1 = "abc";
 193     static const char *s2 = "aBd";
 194     int ret;
 195
 196     ret = _memicmp_l(NULL, NULL, 0, NULL);
 197     ok(!ret, "got %d\n", ret);
 198
 199     SET_EXPECT(invalid_parameter_handler);
 200     errno = 0xdeadbeef;
 201     ret = _memicmp_l(NULL, NULL, 1, NULL);
 202     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 203     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 204     CHECK_CALLED(invalid_parameter_handler);
 205
 206     SET_EXPECT(invalid_parameter_handler);
 207     errno = 0xdeadbeef;
 208     ret = _memicmp_l(s1, NULL, 1, NULL);
 209     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 210     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 211     CHECK_CALLED(invalid_parameter_handler);
 212
 213     SET_EXPECT(invalid_parameter_handler);
 214     errno = 0xdeadbeef;
 215     ret = _memicmp_l(NULL, s2, 1, NULL);
 216     ok(ret == _NLSCMPERROR, "got %d\n", ret);
 217     ok(errno == EINVAL, "Unexpected errno = %d\n", errno);
 218     CHECK_CALLED(invalid_parameter_handler);
 219
 220     ret = _memicmp_l(s1, s2, 2, NULL);
 221     ok(!ret, "got %d\n", ret);
 222
 223     ret = _memicmp_l(s1, s2, 3, NULL);
 224     ok(ret == -1, "got %d\n", ret);
 225 }
 226
 227
 228 static void test___strncnt(void)
 229 {
 230     static const struct
 231     {
 232         const char *str;
 233         size_t size;
 234         size_t ret;
 235     }
 236     strncnt_tests[] =
 237     {
 238         { "a", 0, 0 },
 239         { "a", 1, 1 },
 240         { "a", 10, 1 },
 241         { "abc", 1, 1 },
 242     };
 243     unsigned int i;
 244     size_t ret;
 245
 246     for (i = 0; i < ARRAY_SIZE(strncnt_tests); ++i)
 247     {
 248         ret = __strncnt(strncnt_tests[i].str, strncnt_tests[i].size);
 249         ok(ret == strncnt_tests[i].ret, "%u: unexpected return value %u.\n", i, (int)ret);
 250     }
 251
 252     if (0) /* crashes */
 253     {
 254         ret = __strncnt(NULL, 0);
 255         ret = __strncnt(NULL, 1);
 256     }
 257 }
 258
 259 static void test_C_locale(void)
 260 {
 261     int i, j;
 262     wint_t ret, exp;
 263     _locale_t locale;
 264     static const char *locales[] = { NULL, "C" };
 265
 266     /* C locale only converts case for [a-zA-Z] */
 267     setlocale(LC_ALL, "C");
 268     for (i = 0; i <= 0xffff; i++)
 269     {
 270         ret = tolower(i);
 271         if (i >= 'A' && i <= 'Z')
 272         {
 273             exp = i + 'a' - 'A';
 274             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 275         }
 276         else
 277             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 278
 279         ret = _tolower(i);
 280         exp = i + 'a' - 'A';
 281         ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 282
 283         ret = _o_tolower(i);
 284         if (i >= 'A' && i <= 'Z')
 285         {
 286             exp = i + 'a' - 'A';
 287             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 288         }
 289         else
 290             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 291
 292         ret = towlower(i);
 293         if (i >= 'A' && i <= 'Z')
 294         {
 295             exp = i + 'a' - 'A';
 296             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 297         }
 298         else
 299             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 300
 301         ret = toupper(i);
 302         if (i >= 'a' && i <= 'z')
 303         {
 304             exp = i + 'A' - 'a';
 305             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 306         }
 307         else
 308             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 309
 310         ret = _toupper(i);
 311         exp = i + 'A' - 'a';
 312         ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 313
 314         ret = _o_toupper(i);
 315         if (i >= 'a' && i <= 'z')
 316         {
 317             exp = i + 'A' - 'a';
 318             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 319         }
 320         else
 321             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 322
 323         ret = towupper(i);
 324         if (i >= 'a' && i <= 'z')
 325         {
 326             exp = i + 'A' - 'a';
 327             ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 328         }
 329         else
 330             ok(ret == i, "expected self %x, got %x for C locale\n", i, ret);
 331     }
 332
 333     for (i = 0; i < ARRAY_SIZE(locales); i++) {
 334         locale = locales[i] ? _create_locale(LC_ALL, locales[i]) : NULL;
 335
 336         for (j = 0; j <= 0xffff; j++) {
 337             ret = _towlower_l(j, locale);
 338             if (j >= 'A' && j <= 'Z')
 339             {
 340                 exp = j + 'a' - 'A';
 341                 ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 342             }
 343             else
 344                 ok(ret == j, "expected self %x, got %x for C locale\n", j, ret);
 345
 346             ret = _towupper_l(j, locale);
 347             if (j >= 'a' && j <= 'z')
 348             {
 349                 exp = j + 'A' - 'a';
 350                 ok(ret == exp, "expected %x, got %x for C locale\n", exp, ret);
 351             }
 352             else
 353                 ok(ret == j, "expected self %x, got %x for C locale\n", j, ret);
 354         }
 355
 356         _free_locale(locale);
 357     }
 358 }
 359
 360 static void test_mbsspn( void)
 361 {
 362     unsigned char str1[] = "cabernet";
 363     unsigned char str2[] = "shiraz";
 364     unsigned char set[] = "abc";
 365     unsigned char empty[] = "";
 366     unsigned char mbstr[] = " 2019\x94\x4e" "6\x8c\x8e" "29\x93\xfa";
 367     unsigned char mbset1[] = "0123456789 \x94\x4e";
 368     unsigned char mbset2[] = " \x94\x4e\x8c\x8e";
 369     unsigned char mbset3[] = "\x8e";
 370     int ret, cp = _getmbcp();
 371
 372     ret = _mbsspn(str1, set);
 373     ok(ret == 3, "_mbsspn returns %d should be 3\n", ret);
 374     ret = _mbsspn(str2, set);
 375     ok(ret == 0, "_mbsspn returns %d should be 0\n", ret);
 376     ret = _mbsspn(str1, empty);
 377     ok(ret == 0, "_mbsspn returns %d should be 0\n", ret);
 378
 379     _setmbcp(932);
 380     ret = _mbsspn(mbstr, mbset1);
 381     ok(ret == 8, "_mbsspn returns %d should be 8\n", ret);
 382     ret = _mbsspn(mbstr, mbset2);
 383     ok(ret == 1, "_mbsspn returns %d should be 1\n", ret);
 384     ret = _mbsspn(mbstr+8, mbset1);
 385     ok(ret == 0, "_mbsspn returns %d should be 0\n", ret);
 386     ret = _mbsspn(mbstr+8, mbset2);
 387     ok(ret == 2, "_mbsspn returns %d should be 2\n", ret);
 388     ret = _mbsspn(mbstr, mbset3);
 389     ok(ret == 14, "_mbsspn returns %d should be 14\n", ret);
 390
 391     _setmbcp(cp);
 392 }
 393
 394 static void test_wcstok(void)
 395 {
 396     static const wchar_t *input = L"two words";
 397     wchar_t buffer[16];
 398     wchar_t *token;
 399     wchar_t *next;
 400
 401     next = NULL;
 402     wcscpy(buffer, input);
 403     token = wcstok(buffer, L" ", &next);
 404     ok(!wcscmp(L"two", token), "expected \"two\", got \"%ls\"\n", token);
 405     ok(next == token + 4, "expected %p, got %p\n", token + 4, next);
 406     token = wcstok(NULL, L" ", &next);
 407     ok(!wcscmp(L"words", token), "expected \"words\", got \"%ls\"\n", token);
 408     ok(next == token + 5, "expected %p, got %p\n", token + 5, next);
 409     token = wcstok(NULL, L" ", &next);
 410     ok(!token, "expected NULL, got %p\n", token);
 411
 412     wcscpy(buffer, input);
 413     token = wcstok(buffer, L" ", NULL);
 414     ok(!wcscmp(L"two", token), "expected \"two\", got \"%ls\"\n", token);
 415     token = wcstok(NULL, L" ", NULL);
 416     ok(!wcscmp(L"words", token), "expected \"words\", got \"%ls\"\n", token);
 417     token = wcstok(NULL, L" ", NULL);
 418     ok(!token, "expected NULL, got %p\n", token);
 419 }
 420
 421 static void test__strnicmp(void)
 422 {
 423     static const char str1[] = "TEST";
 424     static const char str2[] = "test";
 425     int ret;
 426
 427     SET_EXPECT(invalid_parameter_handler);
 428     errno = 0xdeadbeef;
 429     ret = _strnicmp(str1, str2, -1);
 430     todo_wine CHECK_CALLED(invalid_parameter_handler);
 431     todo_wine ok(ret == _NLSCMPERROR, "got %d.\n", ret);
 432     todo_wine ok(errno == EINVAL, "Unexpected errno %d.\n", errno);
 433
 434     ret = _strnicmp(str1, str2, 0x7fffffff);
 435     ok(!ret, "got %d.\n", ret);
 436 }
 437
 438 START_TEST(string)
 439 {
 440     ok(_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
 441             "Invalid parameter handler was already set\n");
 442
 443     test_strtod();
 444     test__memicmp();
 445     test__memicmp_l();
 446     test___strncnt();
 447     test_C_locale();
 448     test_mbsspn();
 449     test_wcstok();
 450     test__strnicmp();
 451 }