2 * Copyright 2010 Detlef Riekenberg
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
32 #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 _invalid_parameter_handler (__cdecl *p_set_invalid_parameter_handler)(_invalid_parameter_handler);
61 typedef int (__cdecl *_INITTERM_E_FN)(void);
62 static int (__cdecl *p_initterm_e)(_INITTERM_E_FN *table, _INITTERM_E_FN *end);
63 static void* (__cdecl *p_encode_pointer)(void *);
64 static void* (__cdecl *p_decode_pointer)(void *);
65 static void* (__cdecl *p_encoded_null)(void);
66 static int *p_sys_nerr;
67 static int* (__cdecl *p__sys_nerr)(void);
68 static char **p_sys_errlist;
69 static char** (__cdecl *p__sys_errlist)(void);
70 static __int64 (__cdecl *p_strtoi64)(const char *, char **, int);
71 static unsigned __int64 (__cdecl *p_strtoui64)(const char *, char **, int);
72 static errno_t (__cdecl *p_itoa_s)(int,char*,size_t,int);
73 static int (__cdecl *p_wcsncat_s)(wchar_t *dst, size_t elem, const wchar_t *src, size_t count);
74 static void (__cdecl *p_qsort_s)(void *, size_t, size_t, int (__cdecl *)(void *, const void *, const void *), void *);
75 static int (__cdecl *p_controlfp_s)(unsigned int *, unsigned int, unsigned int);
76 static int (__cdecl *p_atoflt)(_CRT_FLOAT *, char *);
77 static unsigned int (__cdecl *p_set_abort_behavior)(unsigned int, unsigned int);
78 static int (__cdecl *p_sopen_s)(int*, const char*, int, int, int);
79 static int (__cdecl *p_wsopen_s)(int*, const wchar_t*, int, int, int);
80 static void* (__cdecl *p_realloc_crt)(void*, size_t);
81 static void* (__cdecl *p_malloc)(size_t);
82 static void (__cdecl *p_free)(void*);
83 static void* (__cdecl *p_getptd)(void);
84 static int* (__cdecl *p_errno)(void);
85 static __msvcrt_ulong* (__cdecl *p_doserrno)(void);
86 static void (__cdecl *p_srand)(unsigned int);
87 static char* (__cdecl *p_strtok)(char*, const char*);
88 static wchar_t* (__cdecl *p_wcstok)(wchar_t*, const wchar_t*);
89 static char* (__cdecl *p_strerror)(int);
90 static wchar_t* (__cdecl *p_wcserror)(int);
91 static char* (__cdecl *p_tmpnam)(char*);
92 static wchar_t* (__cdecl *p_wtmpnam)(wchar_t*);
93 static char* (__cdecl *p_asctime)(struct tm*);
94 static wchar_t* (__cdecl *p_wasctime)(struct tm*);
95 static struct tm* (__cdecl *p_localtime64)(__time64_t*);
96 static char* (__cdecl *p_ecvt)(double, int, int*, int*);
97 static int* (__cdecl *p_fpecode)(void);
98 static int (__cdecl *p_configthreadlocale)(int);
99 static void* (__cdecl *p_get_terminate)(void);
100 static void* (__cdecl *p_get_unexpected)(void);
104 typedef struct __type_info
112 struct __type_info_node
115 struct __type_info_node* next;
118 static char* (WINAPI *p_type_info_name_internal_method)(type_info*, struct __type_info_node *);
119 static void (WINAPI *ptype_info_dtor)(type_info*);
121 static void* (WINAPI *pEncodePointer)(void *);
123 static int cb_called[4];
124 static int g_qsort_s_context_counter;
126 static inline int almost_equal_f(float f1, float f2)
128 return f1-f2 > -1e-30 && f1-f2 < 1e-30;
133 /* thiscall emulation */
134 /* Emulate a __thiscall */
137 static inline void* do_call_func1(void *func, void *_this)
139 volatile void* retval = 0;
148 return (void*)retval;
151 static inline void* do_call_func2(void *func, void *_this, const void* arg)
153 volatile void* retval = 0;
163 return (void*)retval;
166 static void* do_call_func1(void *func, void *_this)
169 __asm__ __volatile__ ("call *%2"
170 : "=a" (ret), "=c" (dummy)
171 : "g" (func), "1" (_this)
176 static void* do_call_func2(void *func, void *_this, const void* arg)
179 __asm__ __volatile__ ("pushl %3\n\tcall *%2"
180 : "=a" (ret), "=c" (dummy)
181 : "r" (func), "r" (arg), "1" (_this)
187 #define call_func1(func,_this) do_call_func1(func,_this)
188 #define call_func2(func,_this,a) do_call_func2(func,_this,(const void*)a)
192 #define call_func1(func,_this) func(_this)
193 #define call_func2(func,_this,a) func(_this,a)
195 #endif /* __i386__ */
197 static void __cdecl test_invalid_parameter_handler(const wchar_t *expression,
198 const wchar_t *function, const wchar_t *file,
199 unsigned line, uintptr_t arg)
201 CHECK_EXPECT(invalid_parameter_handler);
202 ok(expression == NULL, "expression is not NULL\n");
203 ok(function == NULL, "function is not NULL\n");
204 ok(file == NULL, "file is not NULL\n");
205 ok(line == 0, "line = %u\n", line);
206 ok(arg == 0, "arg = %lx\n", (UINT_PTR)arg);
209 #define SETNOFAIL(x,y) x = (void*)GetProcAddress(hcrt,y)
210 #define SET(x,y) do { SETNOFAIL(x,y); ok(x != NULL, "Export '%s' not found\n", y); } while(0)
211 static BOOL init(void)
216 SetLastError(0xdeadbeef);
217 hcrt = LoadLibraryA("msvcr90.dll");
219 win_skip("msvcr90.dll not installed (got %d)\n", GetLastError());
223 SET(p_set_invalid_parameter_handler, "_set_invalid_parameter_handler");
224 if(p_set_invalid_parameter_handler)
225 ok(p_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
226 "Invalid parameter handler was already set\n");
228 SET(p_initterm_e, "_initterm_e");
229 SET(p_encode_pointer, "_encode_pointer");
230 SET(p_decode_pointer, "_decode_pointer");
231 SET(p_encoded_null, "_encoded_null");
232 SET(p_sys_nerr, "_sys_nerr");
233 SET(p__sys_nerr, "__sys_nerr");
234 SET(p_sys_errlist, "_sys_errlist");
235 SET(p__sys_errlist, "__sys_errlist");
236 SET(p_strtoi64, "_strtoi64");
237 SET(p_strtoui64, "_strtoui64");
238 SET(p_itoa_s, "_itoa_s");
239 SET(p_wcsncat_s,"wcsncat_s" );
240 SET(p_qsort_s, "qsort_s");
241 SET(p_controlfp_s, "_controlfp_s");
242 SET(p_atoflt, "_atoflt");
243 SET(p_set_abort_behavior, "_set_abort_behavior");
244 SET(p_sopen_s, "_sopen_s");
245 SET(p_wsopen_s, "_wsopen_s");
246 SET(p_realloc_crt, "_realloc_crt");
247 SET(p_malloc, "malloc");
249 SET(p_getptd, "_getptd");
250 SET(p_errno, "_errno");
251 SET(p_doserrno, "__doserrno");
252 SET(p_srand, "srand");
253 SET(p_strtok, "strtok");
254 SET(p_wcstok, "wcstok");
255 SET(p_strerror, "strerror");
256 SET(p_wcserror, "_wcserror");
257 SET(p_tmpnam, "tmpnam");
258 SET(p_wtmpnam, "_wtmpnam");
259 SET(p_asctime, "asctime");
260 SET(p_wasctime, "_wasctime");
261 SET(p_localtime64, "_localtime64");
262 SET(p_ecvt, "_ecvt");
263 SET(p_fpecode, "__fpecode");
264 SET(p_configthreadlocale, "_configthreadlocale");
265 SET(p_get_terminate, "_get_terminate");
266 SET(p_get_unexpected, "_get_unexpected");
267 if (sizeof(void *) == 8)
269 SET(p_type_info_name_internal_method, "?_name_internal_method@type_info@@QEBAPEBDPEAU__type_info_node@@@Z");
270 SET(ptype_info_dtor, "??1type_info@@UEAA@XZ");
274 SET(p_type_info_name_internal_method, "?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z");
275 SET(ptype_info_dtor, "??1type_info@@UAE@XZ");
278 hkernel32 = GetModuleHandleA("kernel32.dll");
279 pEncodePointer = (void *) GetProcAddress(hkernel32, "EncodePointer");
283 static int __cdecl initterm_cb0(void)
289 static int __cdecl initterm_cb1(void)
295 static int __cdecl initterm_cb2(void)
302 static void test__initterm_e(void)
304 _INITTERM_E_FN table[4];
307 memset(table, 0, sizeof(table));
309 memset(cb_called, 0, sizeof(cb_called));
311 res = p_initterm_e(table, table);
312 ok( !res && !cb_called[0] && !cb_called[1] && !cb_called[2],
313 "got %d with 0x%x {%d, %d, %d}\n",
314 res, errno, cb_called[0], cb_called[1], cb_called[2]);
316 memset(cb_called, 0, sizeof(cb_called));
318 res = p_initterm_e(table, NULL);
319 ok( !res && !cb_called[0] && !cb_called[1] && !cb_called[2],
320 "got %d with 0x%x {%d, %d, %d}\n",
321 res, errno, cb_called[0], cb_called[1], cb_called[2]);
324 /* this crash on Windows */
326 res = p_initterm_e(NULL, table);
327 trace("got %d with 0x%x\n", res, errno);
330 table[0] = initterm_cb0;
331 memset(cb_called, 0, sizeof(cb_called));
333 res = p_initterm_e(table, &table[1]);
334 ok( !res && (cb_called[0] == 1) && !cb_called[1] && !cb_called[2],
335 "got %d with 0x%x {%d, %d, %d}\n",
336 res, errno, cb_called[0], cb_called[1], cb_called[2]);
339 /* init-function returning failure */
340 table[1] = initterm_cb1;
341 memset(cb_called, 0, sizeof(cb_called));
343 res = p_initterm_e(table, &table[3]);
344 ok( (res == 1) && (cb_called[0] == 1) && (cb_called[1] == 1) && !cb_called[2],
345 "got %d with 0x%x {%d, %d, %d}\n",
346 res, errno, cb_called[0], cb_called[1], cb_called[2]);
348 /* init-function not called, when end < start */
349 memset(cb_called, 0, sizeof(cb_called));
351 res = p_initterm_e(&table[3], table);
352 ok( !res && !cb_called[0] && !cb_called[1] && !cb_called[2],
353 "got %d with 0x%x {%d, %d, %d}\n",
354 res, errno, cb_called[0], cb_called[1], cb_called[2]);
356 /* initialization stop after first non-zero result */
357 table[2] = initterm_cb0;
358 memset(cb_called, 0, sizeof(cb_called));
360 res = p_initterm_e(table, &table[3]);
361 ok( (res == 1) && (cb_called[0] == 1) && (cb_called[1] == 1) && !cb_called[2],
362 "got %d with 0x%x {%d, %d, %d}\n",
363 res, errno, cb_called[0], cb_called[1], cb_called[2]);
365 /* NULL pointer in the array are skipped */
367 table[2] = initterm_cb2;
368 memset(cb_called, 0, sizeof(cb_called));
370 res = p_initterm_e(table, &table[3]);
371 ok( (res == 2) && (cb_called[0] == 1) && !cb_called[1] && (cb_called[2] == 1),
372 "got %d with 0x%x {%d, %d, %d}\n",
373 res, errno, cb_called[0], cb_called[1], cb_called[2]);
377 /* Beware that _encode_pointer is a NOP before XP
378 (the parameter is returned unchanged) */
379 static void test__encode_pointer(void)
383 ptr = (void*)0xdeadbeef;
384 res = p_encode_pointer(ptr);
385 res = p_decode_pointer(res);
386 ok(res == ptr, "Pointers are different after encoding and decoding\n");
388 ok(p_encoded_null() == p_encode_pointer(NULL), "Error encoding null\n");
390 ptr = p_encode_pointer(p_encode_pointer);
391 ok(p_decode_pointer(ptr) == p_encode_pointer, "Error decoding pointer\n");
393 /* Not present before XP */
394 if (!pEncodePointer) {
395 win_skip("EncodePointer not found\n");
399 res = pEncodePointer(p_encode_pointer);
400 ok(ptr == res, "_encode_pointer produced different result than EncodePointer\n");
404 static void test_error_messages(void)
406 int *size, size_copy;
408 size = p__sys_nerr();
410 ok(*p_sys_nerr == *size, "_sys_nerr = %u, size = %u\n", *p_sys_nerr, *size);
413 ok(*p_sys_nerr == *size, "_sys_nerr = %u, size = %u\n", *p_sys_nerr, *size);
417 ok(*p_sys_errlist == *(p__sys_errlist()), "p_sys_errlist != p__sys_errlist()\n");
420 static void test__strtoi64(void)
423 unsigned __int64 ures;
426 SET_EXPECT(invalid_parameter_handler);
427 res = p_strtoi64(NULL, NULL, 10);
428 ok(res == 0, "res != 0\n");
429 CHECK_CALLED(invalid_parameter_handler);
431 SET_EXPECT(invalid_parameter_handler);
432 res = p_strtoi64("123", NULL, 1);
433 ok(res == 0, "res != 0\n");
434 CHECK_CALLED(invalid_parameter_handler);
436 SET_EXPECT(invalid_parameter_handler);
437 res = p_strtoi64("123", NULL, 37);
438 ok(res == 0, "res != 0\n");
439 CHECK_CALLED(invalid_parameter_handler);
441 SET_EXPECT(invalid_parameter_handler);
442 ures = p_strtoui64(NULL, NULL, 10);
443 ok(ures == 0, "res = %d\n", (int)ures);
444 CHECK_CALLED(invalid_parameter_handler);
446 SET_EXPECT(invalid_parameter_handler);
447 ures = p_strtoui64("123", NULL, 1);
448 ok(ures == 0, "res = %d\n", (int)ures);
449 CHECK_CALLED(invalid_parameter_handler);
451 SET_EXPECT(invalid_parameter_handler);
452 ures = p_strtoui64("123", NULL, 37);
453 ok(ures == 0, "res = %d\n", (int)ures);
454 CHECK_CALLED(invalid_parameter_handler);
455 ok(errno == 0xdeadbeef, "errno = %x\n", errno);
458 static void test__itoa_s(void)
463 /* _itoa_s (on msvcr90) doesn't set errno (in case of errors) while msvcrt does
464 * as we always set errno in our msvcrt implementation, don't test here that errno
467 SET_EXPECT(invalid_parameter_handler);
468 ret = p_itoa_s(0, NULL, 0, 0);
469 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
470 CHECK_CALLED(invalid_parameter_handler);
472 memset(buffer, 'X', sizeof(buffer));
473 SET_EXPECT(invalid_parameter_handler);
474 ret = p_itoa_s(0, buffer, 0, 0);
475 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
476 ok(buffer[0] == 'X', "Expected the output buffer to be untouched\n");
477 CHECK_CALLED(invalid_parameter_handler);
479 memset(buffer, 'X', sizeof(buffer));
480 SET_EXPECT(invalid_parameter_handler);
481 ret = p_itoa_s(0, buffer, sizeof(buffer), 0);
482 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
483 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
484 CHECK_CALLED(invalid_parameter_handler);
486 memset(buffer, 'X', sizeof(buffer));
487 SET_EXPECT(invalid_parameter_handler);
488 ret = p_itoa_s(0, buffer, sizeof(buffer), 64);
489 ok(ret == EINVAL, "Expected _itoa_s to return EINVAL, got %d\n", ret);
490 ok(buffer[0] == '\0', "Expected the output buffer to be null terminated\n");
491 CHECK_CALLED(invalid_parameter_handler);
493 memset(buffer, 'X', sizeof(buffer));
494 SET_EXPECT(invalid_parameter_handler);
495 ret = p_itoa_s(12345678, buffer, 4, 10);
496 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
497 ok(!memcmp(buffer, "\000765", 4),
498 "Expected the output buffer to be null terminated with truncated output\n");
499 CHECK_CALLED(invalid_parameter_handler);
501 memset(buffer, 'X', sizeof(buffer));
502 SET_EXPECT(invalid_parameter_handler);
503 ret = p_itoa_s(12345678, buffer, 8, 10);
504 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
505 ok(!memcmp(buffer, "\0007654321", 8),
506 "Expected the output buffer to be null terminated with truncated output\n");
507 CHECK_CALLED(invalid_parameter_handler);
509 memset(buffer, 'X', sizeof(buffer));
510 SET_EXPECT(invalid_parameter_handler);
511 ret = p_itoa_s(-12345678, buffer, 9, 10);
512 ok(ret == ERANGE, "Expected _itoa_s to return ERANGE, got %d\n", ret);
513 ok(!memcmp(buffer, "\00087654321", 9),
514 "Expected the output buffer to be null terminated with truncated output\n");
515 CHECK_CALLED(invalid_parameter_handler);
517 ret = p_itoa_s(12345678, buffer, 9, 10);
518 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
519 ok(!strcmp(buffer, "12345678"),
520 "Expected output buffer string to be \"12345678\", got \"%s\"\n",
523 ret = p_itoa_s(43690, buffer, sizeof(buffer), 2);
524 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
525 ok(!strcmp(buffer, "1010101010101010"),
526 "Expected output buffer string to be \"1010101010101010\", got \"%s\"\n",
529 ret = p_itoa_s(1092009, buffer, sizeof(buffer), 36);
530 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
531 ok(!strcmp(buffer, "nell"),
532 "Expected output buffer string to be \"nell\", got \"%s\"\n",
535 ret = p_itoa_s(5704, buffer, sizeof(buffer), 18);
536 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
537 ok(!strcmp(buffer, "hag"),
538 "Expected output buffer string to be \"hag\", got \"%s\"\n",
541 ret = p_itoa_s(-12345678, buffer, sizeof(buffer), 10);
542 ok(ret == 0, "Expected _itoa_s to return 0, got %d\n", ret);
543 ok(!strcmp(buffer, "-12345678"),
544 "Expected output buffer string to be \"-12345678\", got \"%s\"\n",
548 static void test_wcsncat_s(void)
550 static wchar_t abcW[] = {'a','b','c',0};
555 memcpy(src, abcW, sizeof(abcW));
557 SET_EXPECT(invalid_parameter_handler);
558 ret = p_wcsncat_s(NULL, 4, src, 4);
559 ok(ret == EINVAL, "err = %d\n", ret);
560 CHECK_CALLED(invalid_parameter_handler);
562 SET_EXPECT(invalid_parameter_handler);
563 ret = p_wcsncat_s(dst, 0, src, 4);
564 ok(ret == EINVAL, "err = %d\n", ret);
565 CHECK_CALLED(invalid_parameter_handler);
567 SET_EXPECT(invalid_parameter_handler);
568 ret = p_wcsncat_s(dst, 0, src, _TRUNCATE);
569 ok(ret == EINVAL, "err = %d\n", ret);
570 CHECK_CALLED(invalid_parameter_handler);
572 ret = p_wcsncat_s(dst, 4, NULL, 0);
573 ok(ret == 0, "err = %d\n", ret);
576 SET_EXPECT(invalid_parameter_handler);
577 ret = p_wcsncat_s(dst, 2, src, 4);
578 ok(ret == ERANGE, "err = %d\n", ret);
579 CHECK_CALLED(invalid_parameter_handler);
582 ret = p_wcsncat_s(dst, 2, src, _TRUNCATE);
583 ok(ret == STRUNCATE, "err = %d\n", ret);
584 ok(dst[0] == 'a' && dst[1] == 0, "dst is %s\n", wine_dbgstr_w(dst));
586 memcpy(dst, abcW, sizeof(abcW));
588 SET_EXPECT(invalid_parameter_handler);
589 ret = p_wcsncat_s(dst, 4, src, 4);
590 ok(ret == EINVAL, "err = %d\n", ret);
591 CHECK_CALLED(invalid_parameter_handler);
594 /* Based on dlls/ntdll/tests/string.c */
595 static __cdecl int intcomparefunc(void *context, const void *a, const void *b)
597 const int *p = a, *q = b;
599 ok (a != b, "must never get the same pointer\n");
605 static __cdecl int charcomparefunc(void *context, const void *a, const void *b)
607 const char *p = a, *q = b;
609 ok (a != b, "must never get the same pointer\n");
615 static __cdecl int strcomparefunc(void *context, const void *a, const void *b)
617 const char * const *p = a;
618 const char * const *q = b;
620 ok (a != b, "must never get the same pointer\n");
623 return lstrcmpA(*p, *q);
626 static void test_qsort_s(void)
628 int arr[5] = { 23, 42, 8, 4, 16 };
629 int arr2[5] = { 23, 42, 8, 4, 16 };
630 char carr[5] = { 42, 23, 4, 8, 16 };
631 const char *strarr[7] = {
641 SET_EXPECT(invalid_parameter_handler);
642 p_qsort_s(NULL, 0, 0, NULL, NULL);
643 CHECK_CALLED(invalid_parameter_handler);
645 SET_EXPECT(invalid_parameter_handler);
646 p_qsort_s(NULL, 0, 0, intcomparefunc, NULL);
647 CHECK_CALLED(invalid_parameter_handler);
649 SET_EXPECT(invalid_parameter_handler);
650 p_qsort_s(NULL, 0, sizeof(int), NULL, NULL);
651 CHECK_CALLED(invalid_parameter_handler);
653 SET_EXPECT(invalid_parameter_handler);
654 p_qsort_s(NULL, 1, sizeof(int), intcomparefunc, NULL);
655 CHECK_CALLED(invalid_parameter_handler);
657 g_qsort_s_context_counter = 0;
658 p_qsort_s(NULL, 0, sizeof(int), intcomparefunc, NULL);
659 ok(g_qsort_s_context_counter == 0, "callback shouldn't have been called\n");
661 /* overflow without side effects, other overflow values crash */
662 g_qsort_s_context_counter = 0;
663 p_qsort_s((void*)arr2, (((size_t)1) << (8*sizeof(size_t) - 1)) + 1, sizeof(int), intcomparefunc, &g_qsort_s_context_counter);
664 ok(g_qsort_s_context_counter == 0, "callback shouldn't have been called\n");
665 ok(arr2[0] == 23, "should remain unsorted, arr2[0] is %d\n", arr2[0]);
666 ok(arr2[1] == 42, "should remain unsorted, arr2[1] is %d\n", arr2[1]);
667 ok(arr2[2] == 8, "should remain unsorted, arr2[2] is %d\n", arr2[2]);
668 ok(arr2[3] == 4, "should remain unsorted, arr2[3] is %d\n", arr2[3]);
670 g_qsort_s_context_counter = 0;
671 p_qsort_s((void*)arr, 0, sizeof(int), intcomparefunc, &g_qsort_s_context_counter);
672 ok(g_qsort_s_context_counter == 0, "callback shouldn't have been called\n");
673 ok(arr[0] == 23, "badly sorted, nmemb=0, arr[0] is %d\n", arr[0]);
674 ok(arr[1] == 42, "badly sorted, nmemb=0, arr[1] is %d\n", arr[1]);
675 ok(arr[2] == 8, "badly sorted, nmemb=0, arr[2] is %d\n", arr[2]);
676 ok(arr[3] == 4, "badly sorted, nmemb=0, arr[3] is %d\n", arr[3]);
677 ok(arr[4] == 16, "badly sorted, nmemb=0, arr[4] is %d\n", arr[4]);
679 g_qsort_s_context_counter = 0;
680 p_qsort_s((void*)arr, 1, sizeof(int), intcomparefunc, &g_qsort_s_context_counter);
681 ok(g_qsort_s_context_counter == 0, "callback shouldn't have been called\n");
682 ok(arr[0] == 23, "badly sorted, nmemb=1, arr[0] is %d\n", arr[0]);
683 ok(arr[1] == 42, "badly sorted, nmemb=1, arr[1] is %d\n", arr[1]);
684 ok(arr[2] == 8, "badly sorted, nmemb=1, arr[2] is %d\n", arr[2]);
685 ok(arr[3] == 4, "badly sorted, nmemb=1, arr[3] is %d\n", arr[3]);
686 ok(arr[4] == 16, "badly sorted, nmemb=1, arr[4] is %d\n", arr[4]);
688 SET_EXPECT(invalid_parameter_handler);
689 g_qsort_s_context_counter = 0;
690 p_qsort_s((void*)arr, 5, 0, intcomparefunc, &g_qsort_s_context_counter);
691 ok(g_qsort_s_context_counter == 0, "callback shouldn't have been called\n");
692 ok(arr[0] == 23, "badly sorted, size=0, arr[0] is %d\n", arr[0]);
693 ok(arr[1] == 42, "badly sorted, size=0, arr[1] is %d\n", arr[1]);
694 ok(arr[2] == 8, "badly sorted, size=0, arr[2] is %d\n", arr[2]);
695 ok(arr[3] == 4, "badly sorted, size=0, arr[3] is %d\n", arr[3]);
696 ok(arr[4] == 16, "badly sorted, size=0, arr[4] is %d\n", arr[4]);
697 CHECK_CALLED(invalid_parameter_handler);
699 g_qsort_s_context_counter = 0;
700 p_qsort_s((void*)arr, 5, sizeof(int), intcomparefunc, &g_qsort_s_context_counter);
701 ok(g_qsort_s_context_counter > 0, "callback wasn't called\n");
702 ok(arr[0] == 4, "badly sorted, arr[0] is %d\n", arr[0]);
703 ok(arr[1] == 8, "badly sorted, arr[1] is %d\n", arr[1]);
704 ok(arr[2] == 16, "badly sorted, arr[2] is %d\n", arr[2]);
705 ok(arr[3] == 23, "badly sorted, arr[3] is %d\n", arr[3]);
706 ok(arr[4] == 42, "badly sorted, arr[4] is %d\n", arr[4]);
708 g_qsort_s_context_counter = 0;
709 p_qsort_s((void*)carr, 5, sizeof(char), charcomparefunc, &g_qsort_s_context_counter);
710 ok(g_qsort_s_context_counter > 0, "callback wasn't called\n");
711 ok(carr[0] == 4, "badly sorted, carr[0] is %d\n", carr[0]);
712 ok(carr[1] == 8, "badly sorted, carr[1] is %d\n", carr[1]);
713 ok(carr[2] == 16, "badly sorted, carr[2] is %d\n", carr[2]);
714 ok(carr[3] == 23, "badly sorted, carr[3] is %d\n", carr[3]);
715 ok(carr[4] == 42, "badly sorted, carr[4] is %d\n", carr[4]);
717 g_qsort_s_context_counter = 0;
718 p_qsort_s((void*)strarr, 7, sizeof(char*), strcomparefunc, &g_qsort_s_context_counter);
719 ok(g_qsort_s_context_counter > 0, "callback wasn't called\n");
720 ok(!strcmp(strarr[0],"!"), "badly sorted, strarr[0] is %s\n", strarr[0]);
721 ok(!strcmp(strarr[1],"."), "badly sorted, strarr[1] is %s\n", strarr[1]);
722 ok(!strcmp(strarr[2],"Hello"), "badly sorted, strarr[2] is %s\n", strarr[2]);
723 ok(!strcmp(strarr[3],"Hopefully"), "badly sorted, strarr[3] is %s\n", strarr[3]);
724 ok(!strcmp(strarr[4],"Sorted"), "badly sorted, strarr[4] is %s\n", strarr[4]);
725 ok(!strcmp(strarr[5],"Wine"), "badly sorted, strarr[5] is %s\n", strarr[5]);
726 ok(!strcmp(strarr[6],"World"), "badly sorted, strarr[6] is %s\n", strarr[6]);
729 static void test_controlfp_s(void)
734 SET_EXPECT(invalid_parameter_handler);
735 ret = p_controlfp_s( NULL, ~0, ~0 );
736 ok( ret == EINVAL, "wrong result %d\n", ret );
737 CHECK_CALLED(invalid_parameter_handler);
740 SET_EXPECT(invalid_parameter_handler);
741 ret = p_controlfp_s( &cur, ~0, ~0 );
742 ok( ret == EINVAL, "wrong result %d\n", ret );
743 ok( cur != 0xdeadbeef, "value not set\n" );
744 CHECK_CALLED(invalid_parameter_handler);
747 ret = p_controlfp_s( &cur, 0, 0 );
748 ok( !ret, "wrong result %d\n", ret );
749 ok( cur != 0xdeadbeef, "value not set\n" );
751 SET_EXPECT(invalid_parameter_handler);
753 ret = p_controlfp_s( &cur, 0x80000000, 0x80000000 );
754 ok( ret == EINVAL, "wrong result %d\n", ret );
755 ok( cur != 0xdeadbeef, "value not set\n" );
756 CHECK_CALLED(invalid_parameter_handler);
759 /* mask is only checked when setting invalid bits */
760 ret = p_controlfp_s( &cur, 0, 0x80000000 );
761 ok( !ret, "wrong result %d\n", ret );
762 ok( cur != 0xdeadbeef, "value not set\n" );
772 static const _atoflt_test _atoflt_testdata[] = {
774 { "-13.721", -13.721, 0 },
776 { ".21e12", 0.21e12, 0 },
777 { "214353e-3", 214.353, 0 },
778 { "1d9999999999999999999", 0.0, _OVERFLOW },
780 /* more significant digits */
781 { "1.23456789", 1.23456789, 0 },
782 { "1.23456789e1", 12.3456789, 0 },
783 { "1e39", 0.0, _OVERFLOW },
784 { "1e-39", 0.0, _UNDERFLOW },
788 static void test__atoflt(void)
795 /* crashes on native */
796 p_atoflt(NULL, NULL);
797 p_atoflt(NULL, (char*)_atoflt_testdata[0].str);
798 p_atoflt(&flt, NULL);
801 while (_atoflt_testdata[i].str)
803 ret = p_atoflt(&flt, (char*)_atoflt_testdata[i].str);
804 ok(ret == _atoflt_testdata[i].ret, "got ret %d, expected ret %d, for %s\n", ret,
805 _atoflt_testdata[i].ret, _atoflt_testdata[i].str);
808 ok(almost_equal_f(flt.f, _atoflt_testdata[i].flt), "got %f, expected %f, for %s\n", flt.f,
809 _atoflt_testdata[i].flt, _atoflt_testdata[i].str);
815 static void test__set_abort_behavior(void)
819 /* default is _WRITE_ABORT_MSG | _CALL_REPORTFAULT */
820 res = p_set_abort_behavior(0, 0);
821 ok (res == (_WRITE_ABORT_MSG | _CALL_REPORTFAULT),
822 "got 0x%x (expected 0x%x)\n", res, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
824 /* no internal mask */
825 p_set_abort_behavior(0xffffffff, 0xffffffff);
826 res = p_set_abort_behavior(0, 0);
827 ok (res == 0xffffffff, "got 0x%x (expected 0x%x)\n", res, 0xffffffff);
829 /* set to default value */
830 p_set_abort_behavior(_WRITE_ABORT_MSG | _CALL_REPORTFAULT, 0xffffffff);
833 static void test__sopen_s(void)
837 SET_EXPECT(invalid_parameter_handler);
838 ret = p_sopen_s(NULL, "test", _O_RDONLY, _SH_DENYNO, _S_IREAD);
839 ok(ret == EINVAL, "got %d, expected EINVAL\n", ret);
840 CHECK_CALLED(invalid_parameter_handler);
843 ret = p_sopen_s(&fd, "test", _O_RDONLY, _SH_DENYNO, _S_IREAD);
844 ok(ret == ENOENT, "got %d, expected ENOENT\n", ret);
845 ok(fd == -1, "got %d\n", fd);
848 static void test__wsopen_s(void)
850 wchar_t testW[] = {'t','e','s','t',0};
853 SET_EXPECT(invalid_parameter_handler);
854 ret = p_wsopen_s(NULL, testW, _O_RDONLY, _SH_DENYNO, _S_IREAD);
855 ok(ret == EINVAL, "got %d, expected EINVAL\n", ret);
856 CHECK_CALLED(invalid_parameter_handler);
859 ret = p_wsopen_s(&fd, testW, _O_RDONLY, _SH_DENYNO, _S_IREAD);
860 ok(ret == ENOENT, "got %d, expected ENOENT\n", ret);
861 ok(fd == -1, "got %d\n", fd);
864 static void test__realloc_crt(void)
870 /* crashes on some systems starting Vista */
871 p_realloc_crt(NULL, 10);
875 ok(mem != NULL, "memory not allocated\n");
877 mem = p_realloc_crt(mem, 20);
878 ok(mem != NULL, "memory not reallocated\n");
880 mem = p_realloc_crt(mem, 0);
881 ok(mem == NULL, "memory not freed\n");
883 mem = p_realloc_crt(NULL, 0);
884 ok(mem != NULL, "memory not (re)allocated for size 0\n");
888 static void test_typeinfo(void)
890 static type_info t1 = { NULL, NULL,{'.','?','A','V','t','e','s','t','1','@','@',0,0,0,0,0 } };
891 struct __type_info_node node;
898 name = call_func2(p_type_info_name_internal_method, &t1, &node);
899 ok(name != NULL, "got %p\n", name);
900 ok(name && t1.name && !strcmp(name, t1.name), "bad name '%s' for t1\n", name);
902 ok(t1.name && !strcmp(t1.name, "class test1"), "demangled to '%s' for t1\n", t1.name);
903 call_func1(ptype_info_dtor, &t1);
906 /* Keep in sync with msvcrt/msvcrt.h */
907 struct __thread_data {
911 __msvcrt_ulong thread_doserrno;
913 unsigned int random_seed;
915 wchar_t *wcstok_next;
916 unsigned char *mbstok_next;
917 char *strerror_buffer;
918 wchar_t *wcserror_buffer;
920 wchar_t *wtmpnam_buffer;
922 char *asctime_buffer;
923 wchar_t *wasctime_buffer;
924 struct tm *time_buffer;
929 pthreadmbcinfo mbcinfo;
930 pthreadlocinfo locinfo;
933 void* terminate_handler;
934 void* unexpected_handler;
938 EXCEPTION_RECORD *exc_record;
941 static void test_getptd(void)
943 struct __thread_data *ptd = p_getptd();
944 DWORD tid = GetCurrentThreadId();
945 wchar_t testW[] = {'t','e','s','t',0}, tW[] = {'t',0}, *wp;
946 char test[] = "test", *p;
950 void *mbcinfo, *locinfo;
952 ok(ptd->tid == tid, "ptd->tid = %x, expected %x\n", ptd->tid, tid);
953 ok(ptd->handle == INVALID_HANDLE_VALUE, "ptd->handle = %p\n", ptd->handle);
954 ok(p_errno() == &ptd->thread_errno, "ptd->thread_errno is different then _errno()\n");
955 ok(p_doserrno() == &ptd->thread_doserrno, "ptd->thread_doserrno is different then __doserrno()\n");
957 ok(ptd->random_seed == 1234, "ptd->random_seed = %d\n", ptd->random_seed);
958 p = p_strtok(test, "t");
959 ok(ptd->strtok_next == p+3, "ptd->strtok_next is incorrect\n");
960 wp = p_wcstok(testW, tW);
961 ok(ptd->wcstok_next == wp+3, "ptd->wcstok_next is incorrect\n");
962 ok(p_strerror(0) == ptd->strerror_buffer, "ptd->strerror_buffer is incorrect\n");
963 ok(p_wcserror(0) == ptd->wcserror_buffer, "ptd->wcserror_buffer is incorrect\n");
964 ok(p_tmpnam(NULL) == ptd->tmpnam_buffer, "ptd->tmpnam_buffer is incorrect\n");
965 ok(p_wtmpnam(NULL) == ptd->wtmpnam_buffer, "ptd->wtmpnam_buffer is incorrect\n");
966 memset(&time, 0, sizeof(time));
968 ok(p_asctime(&time) == ptd->asctime_buffer, "ptd->asctime_buffer is incorrect\n");
969 ok(p_wasctime(&time) == ptd->wasctime_buffer, "ptd->wasctime_buffer is incorrect\n");
970 ok(p_localtime64(&secs) == ptd->time_buffer, "ptd->time_buffer is incorrect\n");
971 ok(p_ecvt(3.12, 1, &dec, &sign) == ptd->efcvt_buffer, "ptd->efcvt_buffer is incorrect\n");
972 ok(p_fpecode() == &ptd->fpecode, "ptd->fpecode is incorrect\n");
973 mbcinfo = ptd->mbcinfo;
974 locinfo = ptd->locinfo;
975 todo_wine ok(ptd->have_locale == 1, "ptd->have_locale = %x\n", ptd->have_locale);
976 p_configthreadlocale(1);
977 todo_wine ok(mbcinfo == ptd->mbcinfo, "ptd->mbcinfo != mbcinfo\n");
978 todo_wine ok(locinfo == ptd->locinfo, "ptd->locinfo != locinfo\n");
979 todo_wine ok(ptd->have_locale == 3, "ptd->have_locale = %x\n", ptd->have_locale);
980 ok(p_get_terminate() == ptd->terminate_handler, "ptd->terminate_handler != _get_terminate()\n");
981 ok(p_get_unexpected() == ptd->unexpected_handler, "ptd->unexpected_handler != _get_unexpected()\n");
990 test__encode_pointer();
991 test_error_messages();
998 test__set_abort_behavior();
1001 test__realloc_crt();