2 * Copyright 2015 Martin Storsjo
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.
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.
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
30 #include "wine/test.h"
34 #define DEFINE_EXPECT(func) \
35 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
37 #define SET_EXPECT(func) \
38 expect_ ## func = TRUE
40 #define CHECK_EXPECT2(func) \
42 ok(expect_ ##func, "unexpected call " #func "\n"); \
43 called_ ## func = TRUE; \
46 #define CHECK_EXPECT(func) \
48 CHECK_EXPECT2(func); \
49 expect_ ## func = FALSE; \
52 #define CHECK_CALLED(func) \
54 ok(called_ ## func, "expected " #func "\n"); \
55 expect_ ## func = called_ ## func = FALSE; \
58 DEFINE_EXPECT(invalid_parameter_handler
);
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
)
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 = %Ix\n", arg
);
72 _ACRTIMP
int __cdecl
_o_tolower(int);
73 _ACRTIMP
int __cdecl
_o_toupper(int);
75 static BOOL
local_isnan(double d
)
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
)
87 d
= strtod(string
, &end
);
89 ok_(__FILE__
, line
)(errno
== 0xdeadbeef, "errno = %d\n", errno
);
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
);
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
);
99 static void test_strtod(void)
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
);
114 test_strtod_str("NAN", NAN
, 3);
115 test_strtod_str("nan", NAN
, 3);
116 test_strtod_str("NaN", NAN
, 3);
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);
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);
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);
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 test_strtod_str("2.48e-324", 4.9406564584124654e-324, 9);
152 test_strtod_str_errno("2.47e-324", 0, 9, ERANGE
);
155 static void test_strtof(void)
157 static const struct {
163 { "12.1", 4, 12.1f
},
164 { "-13.721", 7, -13.721f
},
165 { "1.e40", 5, INFINITY
, ERANGE
},
166 { "-1.e40", 6, -INFINITY
, ERANGE
},
169 { "1.4e-45", 7, 1.4e-45f
},
170 { "-1.4e-45", 8, -1.4e-45f
},
171 { "1.e-60", 6, 0, ERANGE
},
172 { "-1.e-60", 7, 0, ERANGE
},
179 for (i
=0; i
<ARRAY_SIZE(tests
); i
++)
182 f
= strtof(tests
[i
].str
, &end
);
183 ok(f
== tests
[i
].ret
, "%d) f = %.16e\n", i
, f
);
184 ok(end
== tests
[i
].str
+ tests
[i
].len
, "%d) len = %d\n",
185 i
, (int)(end
- tests
[i
].str
));
186 ok(errno
== tests
[i
].err
|| (!tests
[i
].err
&& errno
== 0xdeadbeef),
187 "%d) errno = %d\n", i
, errno
);
191 static void test__memicmp(void)
193 static const char *s1
= "abc";
194 static const char *s2
= "aBd";
197 ret
= _memicmp(NULL
, NULL
, 0);
198 ok(!ret
, "got %d\n", ret
);
200 SET_EXPECT(invalid_parameter_handler
);
202 ret
= _memicmp(NULL
, NULL
, 1);
203 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
204 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
205 CHECK_CALLED(invalid_parameter_handler
);
207 SET_EXPECT(invalid_parameter_handler
);
209 ret
= _memicmp(s1
, NULL
, 1);
210 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
211 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
212 CHECK_CALLED(invalid_parameter_handler
);
214 SET_EXPECT(invalid_parameter_handler
);
216 ret
= _memicmp(NULL
, s2
, 1);
217 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
218 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
219 CHECK_CALLED(invalid_parameter_handler
);
221 ret
= _memicmp(s1
, s2
, 2);
222 ok(!ret
, "got %d\n", ret
);
224 ret
= _memicmp(s1
, s2
, 3);
225 ok(ret
== -1, "got %d\n", ret
);
228 static void test__memicmp_l(void)
230 static const char *s1
= "abc";
231 static const char *s2
= "aBd";
234 ret
= _memicmp_l(NULL
, NULL
, 0, NULL
);
235 ok(!ret
, "got %d\n", ret
);
237 SET_EXPECT(invalid_parameter_handler
);
239 ret
= _memicmp_l(NULL
, NULL
, 1, NULL
);
240 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
241 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
242 CHECK_CALLED(invalid_parameter_handler
);
244 SET_EXPECT(invalid_parameter_handler
);
246 ret
= _memicmp_l(s1
, NULL
, 1, NULL
);
247 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
248 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
249 CHECK_CALLED(invalid_parameter_handler
);
251 SET_EXPECT(invalid_parameter_handler
);
253 ret
= _memicmp_l(NULL
, s2
, 1, NULL
);
254 ok(ret
== _NLSCMPERROR
, "got %d\n", ret
);
255 ok(errno
== EINVAL
, "Unexpected errno = %d\n", errno
);
256 CHECK_CALLED(invalid_parameter_handler
);
258 ret
= _memicmp_l(s1
, s2
, 2, NULL
);
259 ok(!ret
, "got %d\n", ret
);
261 ret
= _memicmp_l(s1
, s2
, 3, NULL
);
262 ok(ret
== -1, "got %d\n", ret
);
266 static void test___strncnt(void)
284 for (i
= 0; i
< ARRAY_SIZE(strncnt_tests
); ++i
)
286 ret
= __strncnt(strncnt_tests
[i
].str
, strncnt_tests
[i
].size
);
287 ok(ret
== strncnt_tests
[i
].ret
, "%u: unexpected return value %u.\n", i
, (int)ret
);
292 ret
= __strncnt(NULL
, 0);
293 ret
= __strncnt(NULL
, 1);
297 static void test_C_locale(void)
302 static const char *locales
[] = { NULL
, "C" };
304 /* C locale only converts case for [a-zA-Z] */
305 setlocale(LC_ALL
, "C");
306 for (i
= 0; i
<= 0xffff; i
++)
309 if (i
>= 'A' && i
<= 'Z')
312 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
315 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
319 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
322 if (i
>= 'A' && i
<= 'Z')
325 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
328 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
331 if (i
>= 'A' && i
<= 'Z')
334 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
337 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
340 if (i
>= 'a' && i
<= 'z')
343 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
346 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
350 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
353 if (i
>= 'a' && i
<= 'z')
356 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
359 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
362 if (i
>= 'a' && i
<= 'z')
365 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
368 ok(ret
== i
, "expected self %x, got %x for C locale\n", i
, ret
);
371 for (i
= 0; i
< ARRAY_SIZE(locales
); i
++) {
372 locale
= locales
[i
] ? _create_locale(LC_ALL
, locales
[i
]) : NULL
;
374 for (j
= 0; j
<= 0xffff; j
++) {
375 ret
= _towlower_l(j
, locale
);
376 if (j
>= 'A' && j
<= 'Z')
379 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
382 ok(ret
== j
, "expected self %x, got %x for C locale\n", j
, ret
);
384 ret
= _towupper_l(j
, locale
);
385 if (j
>= 'a' && j
<= 'z')
388 ok(ret
== exp
, "expected %x, got %x for C locale\n", exp
, ret
);
391 ok(ret
== j
, "expected self %x, got %x for C locale\n", j
, ret
);
394 _free_locale(locale
);
398 static void test_mbsspn( void)
400 unsigned char str1
[] = "cabernet";
401 unsigned char str2
[] = "shiraz";
402 unsigned char set
[] = "abc";
403 unsigned char empty
[] = "";
404 unsigned char mbstr
[] = " 2019\x94\x4e" "6\x8c\x8e" "29\x93\xfa";
405 unsigned char mbset1
[] = "0123456789 \x94\x4e";
406 unsigned char mbset2
[] = " \x94\x4e\x8c\x8e";
407 unsigned char mbset3
[] = "\x8e";
408 int ret
, cp
= _getmbcp();
410 ret
= _mbsspn(str1
, set
);
411 ok(ret
== 3, "_mbsspn returns %d should be 3\n", ret
);
412 ret
= _mbsspn(str2
, set
);
413 ok(ret
== 0, "_mbsspn returns %d should be 0\n", ret
);
414 ret
= _mbsspn(str1
, empty
);
415 ok(ret
== 0, "_mbsspn returns %d should be 0\n", ret
);
418 ret
= _mbsspn(mbstr
, mbset1
);
419 ok(ret
== 8, "_mbsspn returns %d should be 8\n", ret
);
420 ret
= _mbsspn(mbstr
, mbset2
);
421 ok(ret
== 1, "_mbsspn returns %d should be 1\n", ret
);
422 ret
= _mbsspn(mbstr
+8, mbset1
);
423 ok(ret
== 0, "_mbsspn returns %d should be 0\n", ret
);
424 ret
= _mbsspn(mbstr
+8, mbset2
);
425 ok(ret
== 2, "_mbsspn returns %d should be 2\n", ret
);
426 ret
= _mbsspn(mbstr
, mbset3
);
427 ok(ret
== 14, "_mbsspn returns %d should be 14\n", ret
);
432 static void test_wcstok(void)
434 static const wchar_t *input
= L
"two words";
440 wcscpy(buffer
, input
);
441 token
= wcstok(buffer
, L
" ", &next
);
442 ok(!wcscmp(L
"two", token
), "expected \"two\", got \"%ls\"\n", token
);
443 ok(next
== token
+ 4, "expected %p, got %p\n", token
+ 4, next
);
444 token
= wcstok(NULL
, L
" ", &next
);
445 ok(!wcscmp(L
"words", token
), "expected \"words\", got \"%ls\"\n", token
);
446 ok(next
== token
+ 5, "expected %p, got %p\n", token
+ 5, next
);
447 token
= wcstok(NULL
, L
" ", &next
);
448 ok(!token
, "expected NULL, got %p\n", token
);
450 wcscpy(buffer
, input
);
451 token
= wcstok(buffer
, L
" ", NULL
);
452 ok(!wcscmp(L
"two", token
), "expected \"two\", got \"%ls\"\n", token
);
453 token
= wcstok(NULL
, L
" ", NULL
);
454 ok(!wcscmp(L
"words", token
), "expected \"words\", got \"%ls\"\n", token
);
455 token
= wcstok(NULL
, L
" ", NULL
);
456 ok(!token
, "expected NULL, got %p\n", token
);
459 wcscpy(buffer
, input
);
460 token
= wcstok(buffer
, L
"=", &next
);
461 ok(!wcscmp(token
, input
), "expected \"%ls\", got \"%ls\"\n", input
, token
);
462 ok(next
== buffer
+ wcslen(input
), "expected %p, got %p\n", buffer
+ wcslen(input
), next
);
463 token
= wcstok(NULL
, L
"=", &next
);
464 ok(!token
, "expected NULL, got \"%ls\"\n", token
);
465 ok(next
== buffer
+ wcslen(input
), "expected %p, got %p\n", buffer
+ wcslen(input
), next
);
469 token
= wcstok(buffer
, L
"=", &next
);
470 ok(token
== NULL
, "expected NULL, got \"%ls\"\n", token
);
471 ok(next
== buffer
, "expected %p, got %p\n", buffer
, next
);
472 token
= wcstok(NULL
, L
"=", &next
);
473 ok(!token
, "expected NULL, got \"%ls\"\n", token
);
474 ok(next
== buffer
, "expected %p, got %p\n", buffer
, next
);
477 static void test__strnicmp(void)
479 static const char str1
[] = "TEST";
480 static const char str2
[] = "test";
483 SET_EXPECT(invalid_parameter_handler
);
485 ret
= _strnicmp(str1
, NULL
, 2);
486 CHECK_CALLED(invalid_parameter_handler
);
487 ok(ret
== _NLSCMPERROR
, "got %d.\n", ret
);
488 ok(errno
== EINVAL
, "Unexpected errno %d.\n", errno
);
490 SET_EXPECT(invalid_parameter_handler
);
492 ret
= _strnicmp(str1
, str2
, -1);
493 CHECK_CALLED(invalid_parameter_handler
);
494 ok(ret
== _NLSCMPERROR
, "got %d.\n", ret
);
495 ok(errno
== EINVAL
, "Unexpected errno %d.\n", errno
);
497 ret
= _strnicmp(str1
, str2
, 0);
498 ok(!ret
, "got %d.\n", ret
);
500 ret
= _strnicmp(str1
, str2
, 0x7fffffff);
501 ok(!ret
, "got %d.\n", ret
);
503 /* If numbers of characters to compare is too big return error */
504 SET_EXPECT(invalid_parameter_handler
);
506 ret
= _strnicmp(str1
, str2
, 0x80000000);
507 CHECK_CALLED(invalid_parameter_handler
);
508 ok(ret
== _NLSCMPERROR
, "got %d.\n", ret
);
509 ok(errno
== EINVAL
, "Unexpected errno %d.\n", errno
);
512 static void test_wcsnicmp(void)
514 static const wchar_t str1
[] = L
"TEST";
515 static const wchar_t str2
[] = L
"test";
519 ret
= wcsnicmp(str1
, str2
, -1);
520 ok(!ret
, "got %d.\n", ret
);
522 ret
= wcsnicmp(str1
, str2
, 0x7fffffff);
523 ok(!ret
, "got %d.\n", ret
);
526 static void test_SpecialCasing(void)
537 struct test ucases
[] = {
538 {"English", 'I', 'i'}, /* LATIN CAPITAL LETTER I */
539 {"English", 0x0130}, /* LATIN CAPITAL LETTER I WITH DOT ABOVE */
541 {"Turkish", 'I', 'i'}, /* LATIN CAPITAL LETTER I */
542 {"Turkish", 0x0130}, /* LATIN CAPITAL LETTER I WITH DOT ABOVE */
544 struct test lcases
[] = {
545 {"English", 'i', 'I'}, /* LATIN SMALL LETTER I */
546 {"English", 0x0131}, /* LATIN SMALL LETTER DOTLESS I */
548 {"Turkish", 'i', 'I'}, /* LATIN SMALL LETTER I */
549 {"Turkish", 0x0131}, /* LATIN SMALL LETTER DOTLESS I */
552 for (i
= 0; i
< ARRAY_SIZE(ucases
); i
++) {
553 if (!setlocale(LC_ALL
, ucases
[i
].lang
)) {
554 win_skip("skipping special case tests for %s\n", ucases
[i
].lang
);
558 ret
= towlower(ucases
[i
].ch
);
559 exp
= ucases
[i
].exp
? ucases
[i
].exp
: ucases
[i
].ch
;
560 ok(ret
== exp
, "expected lowercase %x, got %x for locale %s\n", exp
, ret
, ucases
[i
].lang
);
563 for (i
= 0; i
< ARRAY_SIZE(lcases
); i
++) {
564 if (!setlocale(LC_ALL
, lcases
[i
].lang
)) {
565 win_skip("skipping special case tests for %s\n", lcases
[i
].lang
);
569 ret
= towupper(lcases
[i
].ch
);
570 exp
= lcases
[i
].exp
? lcases
[i
].exp
: lcases
[i
].ch
;
571 ok(ret
== exp
, "expected uppercase %x, got %x for locale %s\n", exp
, ret
, lcases
[i
].lang
);
574 setlocale(LC_ALL
, "C");
576 /* test _towlower_l creating locale */
577 for (i
= 0; i
< ARRAY_SIZE(ucases
); i
++) {
578 if (!(locale
= _create_locale(LC_ALL
, ucases
[i
].lang
))) {
579 win_skip("locale %s not available. skipping\n", ucases
[i
].lang
);
583 ret
= _towlower_l(ucases
[i
].ch
, locale
);
584 exp
= ucases
[i
].exp
? ucases
[i
].exp
: ucases
[i
].ch
;
585 ok(ret
== exp
, "expected lowercase %x, got %x for locale %s\n", exp
, ret
, ucases
[i
].lang
);
587 _free_locale(locale
);
590 /* test _towupper_l creating locale */
591 for (i
= 0; i
< ARRAY_SIZE(lcases
); i
++) {
592 if (!(locale
= _create_locale(LC_ALL
, lcases
[i
].lang
))) {
593 win_skip("locale %s not available. skipping\n", lcases
[i
].lang
);
597 ret
= _towupper_l(lcases
[i
].ch
, locale
);
598 exp
= lcases
[i
].exp
? lcases
[i
].exp
: lcases
[i
].ch
;
599 ok(ret
== exp
, "expected uppercase %x, got %x for locale %s\n", exp
, ret
, lcases
[i
].lang
);
601 _free_locale(locale
);
605 static void test__mbbtype_l(void)
610 _setmbcp(_MB_CP_LOCALE
);
611 for (c
= 0; c
< 256; ++c
)
613 expected
= _mbbtype(c
, 0);
614 ret
= _mbbtype_l(c
, 0, NULL
);
615 ok(ret
== expected
, "c %#x, got ret %#x, expected %#x.\n", c
, ret
, expected
);
617 expected
= _mbbtype(c
, 1);
618 ret
= _mbbtype_l(c
, 1, NULL
);
619 ok(ret
== expected
, "c %#x, got ret %#x, expected %#x.\n", c
, ret
, expected
);
623 static void test_strcmp(void)
625 int ret
= strcmp( "abc", "abcd" );
626 ok( ret
== -1, "wrong ret %d\n", ret
);
627 ret
= strcmp( "", "abc" );
628 ok( ret
== -1, "wrong ret %d\n", ret
);
629 ret
= strcmp( "abc", "ab\xa0" );
630 ok( ret
== -1, "wrong ret %d\n", ret
);
631 ret
= strcmp( "ab\xb0", "ab\xa0" );
632 ok( ret
== 1, "wrong ret %d\n", ret
);
633 ret
= strcmp( "ab\xc2", "ab\xc2" );
634 ok( ret
== 0, "wrong ret %d\n", ret
);
636 ret
= strncmp( "abc", "abcd", 3 );
637 ok( ret
== 0, "wrong ret %d\n", ret
);
638 ret
= strncmp( "", "abc", 3 );
639 ok( ret
== -1, "wrong ret %d\n", ret
);
640 ret
= strncmp( "abc", "ab\xa0", 4 );
641 ok( ret
== -1, "wrong ret %d\n", ret
);
642 ret
= strncmp( "ab\xb0", "ab\xa0", 3 );
643 ok( ret
== 1, "wrong ret %d\n", ret
);
644 ret
= strncmp( "ab\xb0", "ab\xa0", 2 );
645 ok( ret
== 0, "wrong ret %d\n", ret
);
646 ret
= strncmp( "ab\xc2", "ab\xc2", 3 );
647 ok( ret
== 0, "wrong ret %d\n", ret
);
648 ret
= strncmp( "abc", "abd", 0 );
649 ok( ret
== 0, "wrong ret %d\n", ret
);
650 ret
= strncmp( "abc", "abc", 12 );
651 ok( ret
== 0, "wrong ret %d\n", ret
);
654 #define expect_bin(buf, value, len) { ok(memcmp((buf), value, len) == 0, \
655 "Binary buffer mismatch - expected %s, got %s\n", \
656 debugstr_an(value, len), debugstr_an((char *)(buf), len)); }
658 static void test__mbsncpy_s(void)
660 unsigned char *mbstring
= (unsigned char *)"\xb0\xb1\xb2\xb3Q\xb4\xb5\x0";
661 unsigned char *mbstring2
= (unsigned char *)"\xb0\x0";
662 unsigned char buf
[16];
669 skip("Code page 936 is not available, skipping test.\n");
674 memset(buf
, 0xcc, sizeof(buf
));
675 err
= _mbsncpy_s(NULL
, 0, mbstring
, 0);
676 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
677 ok(!err
, "got %d.\n", err
);
680 memset(buf
, 0xcc, sizeof(buf
));
681 err
= _mbsncpy_s(buf
, 6, mbstring
, 1);
682 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
683 ok(!err
, "got %d.\n", err
);
684 expect_bin(buf
, "\xb0\xb1\0\xcc", 4);
686 memset(buf
, 0xcc, sizeof(buf
));
688 err
= _mbsncpy_s(buf
, 6, mbstring
, 2);
689 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
690 ok(!err
, "got %d.\n", err
);
691 expect_bin(buf
, "\xb0\xb1\xb2\xb3\0\xcc", 6);
694 memset(buf
, 0xcc, sizeof(buf
));
695 err
= _mbsncpy_s(buf
, 2, mbstring
, _TRUNCATE
);
696 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
697 ok(err
== STRUNCATE
, "got %d.\n", err
);
698 expect_bin(buf
, "\x00\xb1\xcc", 3);
700 memset(buf
, 0xcc, sizeof(buf
));
701 SET_EXPECT(invalid_parameter_handler
);
703 err
= _mbsncpy_s(buf
, 2, mbstring
, 1);
704 ok(errno
== err
, "got %d.\n", errno
);
705 CHECK_CALLED(invalid_parameter_handler
);
706 ok(err
== ERANGE
, "got %d.\n", err
);
707 expect_bin(buf
, "\x0\xcc\xcc", 3);
709 memset(buf
, 0xcc, sizeof(buf
));
710 SET_EXPECT(invalid_parameter_handler
);
712 err
= _mbsncpy_s(buf
, 2, mbstring
, 3);
713 ok(errno
== err
, "got %d\n", errno
);
714 CHECK_CALLED(invalid_parameter_handler
);
715 ok(err
== ERANGE
, "got %d.\n", err
);
716 expect_bin(buf
, "\x0\xcc\xcc", 3);
718 memset(buf
, 0xcc, sizeof(buf
));
719 SET_EXPECT(invalid_parameter_handler
);
721 err
= _mbsncpy_s(buf
, 1, mbstring
, 3);
722 ok(errno
== err
, "got %d\n", errno
);
723 CHECK_CALLED(invalid_parameter_handler
);
724 ok(err
== ERANGE
, "got %d.\n", err
);
725 expect_bin(buf
, "\x0\xcc", 2);
727 memset(buf
, 0xcc, sizeof(buf
));
728 SET_EXPECT(invalid_parameter_handler
);
730 err
= _mbsncpy_s(buf
, 0, mbstring
, 3);
731 ok(errno
== err
, "got %d\n", errno
);
732 CHECK_CALLED(invalid_parameter_handler
);
733 ok(err
== EINVAL
, "got %d.\n", err
);
734 expect_bin(buf
, "\xcc", 1);
736 memset(buf
, 0xcc, sizeof(buf
));
737 SET_EXPECT(invalid_parameter_handler
);
739 err
= _mbsncpy_s(buf
, 0, mbstring
, 0);
740 ok(errno
== err
, "got %d\n", errno
);
741 CHECK_CALLED(invalid_parameter_handler
);
742 ok(err
== EINVAL
, "got %d.\n", err
);
743 expect_bin(buf
, "\xcc", 1);
745 memset(buf
, 0xcc, sizeof(buf
));
747 err
= _mbsncpy_s(buf
, -1, mbstring
, 0);
748 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
749 ok(!err
, "got %d.\n", err
);
750 expect_bin(buf
, "\x0\xcc", 2);
752 memset(buf
, 0xcc, sizeof(buf
));
754 err
= _mbsncpy_s(buf
, -1, mbstring
, 256);
755 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
756 ok(!err
, "got %d.\n", err
);
757 expect_bin(buf
, "\xb0\xb1\xb2\xb3Q\xb4\xb5\x0\xcc", 9);
759 memset(buf
, 0xcc, sizeof(buf
));
761 err
= _mbsncpy_s(buf
, 1, mbstring2
, 4);
762 ok(errno
== err
, "got %d\n", errno
);
763 ok(err
== EILSEQ
, "got %d.\n", err
);
764 expect_bin(buf
, "\x0\xcc", 2);
766 memset(buf
, 0xcc, sizeof(buf
));
768 err
= _mbsncpy_s(buf
, 2, mbstring2
, 4);
769 ok(errno
== err
, "got %d\n", errno
);
770 ok(err
== EILSEQ
, "got %d.\n", err
);
771 expect_bin(buf
, "\x0\xcc", 2);
773 memset(buf
, 0xcc, sizeof(buf
));
775 err
= _mbsncpy_s(buf
, 1, mbstring2
, _TRUNCATE
);
776 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
777 ok(err
== STRUNCATE
, "got %d.\n", err
);
778 expect_bin(buf
, "\x0\xcc", 2);
780 memset(buf
, 0xcc, sizeof(buf
));
782 err
= _mbsncpy_s(buf
, 2, mbstring2
, _TRUNCATE
);
783 ok(errno
== 0xdeadbeef, "got %d\n", errno
);
784 ok(!err
, "got %d.\n", err
);
785 expect_bin(buf
, "\xb0\x0\xcc", 3);
787 memset(buf
, 0xcc, sizeof(buf
));
789 err
= _mbsncpy_s(buf
, 1, mbstring2
, 1);
790 ok(errno
== err
, "got %d\n", errno
);
791 ok(err
== EILSEQ
, "got %d.\n", err
);
792 expect_bin(buf
, "\x0\xcc", 2);
794 memset(buf
, 0xcc, sizeof(buf
));
796 err
= _mbsncpy_s(buf
, 2, mbstring2
, 1);
797 ok(errno
== err
, "got %d\n", errno
);
798 ok(err
== EILSEQ
, "got %d.\n", err
);
799 expect_bin(buf
, "\x0\xcc", 2);
801 memset(buf
, 0xcc, sizeof(buf
));
803 err
= _mbsncpy_s(buf
, 3, mbstring2
, 1);
804 ok(errno
== err
, "got %d\n", errno
);
805 ok(err
== EILSEQ
, "got %d.\n", err
);
806 expect_bin(buf
, "\x0\xcc", 2);
808 memset(buf
, 0xcc, sizeof(buf
));
810 err
= _mbsncpy_s(buf
, 3, mbstring2
, 2);
811 ok(errno
== err
, "got %d\n", errno
);
812 ok(err
== EILSEQ
, "got %d.\n", err
);
813 expect_bin(buf
, "\x0\xcc", 2);
820 ok(_set_invalid_parameter_handler(test_invalid_parameter_handler
) == NULL
,
821 "Invalid parameter handler was already set\n");
833 test_SpecialCasing();