1 /*
2 * Unit tests for miscellaneous msvcrt functions
3 *
4 * Copyright 2010 Andrew Nguyen
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "wine/test.h"
22 #include <errno.h>
23 #include <stdio.h>
24 #include <math.h>
25 #include "msvcrt.h"
26 #include <process.h>
27
__port_infinity(void)28 static inline float __port_infinity(void)
29 {
30 static const unsigned __inf_bytes = 0x7f800000;
31 return *(const float *)&__inf_bytes;
32 }
33 #ifdef __REACTOS__
34 #undef INFINITY
35 #endif
36 #define INFINITY __port_infinity()
37
__port_nan(void)38 static inline float __port_nan(void)
39 {
40 static const unsigned __nan_bytes = 0x7fc00000;
41 return *(const float *)&__nan_bytes;
42 }
43 #ifdef __REACTOS__
44 #undef NAN
45 #endif
46 #define NAN __port_nan()
47
almost_equal(double d1,double d2)48 static inline BOOL almost_equal(double d1, double d2) {
49 if(d1-d2>-1e-30 && d1-d2<1e-30)
50 return TRUE;
51 return FALSE;
52 }
53
54 /* MS' "long double" is an 80 bit FP that takes 12 bytes*/
55 struct uld { ULONG lo, hi, exp; };
56
57 static int (__cdecl *prand_s)(unsigned int *);
58 static int (__cdecl *pI10_OUTPUT)(struct uld, int, int, void*);
59 static int (__cdecl *pstrerror_s)(char *, MSVCRT_size_t, int);
60 static int (__cdecl *p_get_doserrno)(int *);
61 static int (__cdecl *p_get_errno)(int *);
62 static int (__cdecl *p_set_doserrno)(int);
63 static int (__cdecl *p_set_errno)(int);
64 static void (__cdecl *p__invalid_parameter)(const wchar_t*,
65 const wchar_t*, const wchar_t*, unsigned int, uintptr_t);
66 static void (__cdecl *p_qsort_s)(void*, MSVCRT_size_t, MSVCRT_size_t,
67 int (__cdecl*)(void*, const void*, const void*), void*);
68 static double (__cdecl *p_atan)(double);
69 static double (__cdecl *p_exp)(double);
70 static double (__cdecl *p_tanh)(double);
71 static void *(__cdecl *p_lfind_s)(const void*, const void*, unsigned int*,
72 size_t, int (__cdecl *)(void*, const void*, const void*), void*);
73
init(void)74 static void init(void)
75 {
76 HMODULE hmod = GetModuleHandleA("msvcrt.dll");
77
78 prand_s = (void *)GetProcAddress(hmod, "rand_s");
79 pI10_OUTPUT = (void*)GetProcAddress(hmod, "$I10_OUTPUT");
80 pstrerror_s = (void *)GetProcAddress(hmod, "strerror_s");
81 p_get_doserrno = (void *)GetProcAddress(hmod, "_get_doserrno");
82 p_get_errno = (void *)GetProcAddress(hmod, "_get_errno");
83 p_set_doserrno = (void *)GetProcAddress(hmod, "_set_doserrno");
84 p_set_errno = (void *)GetProcAddress(hmod, "_set_errno");
85 p__invalid_parameter = (void *)GetProcAddress(hmod, "_invalid_parameter");
86 p_qsort_s = (void *)GetProcAddress(hmod, "qsort_s");
87 p_atan = (void *)GetProcAddress(hmod, "atan");
88 p_exp = (void *)GetProcAddress(hmod, "exp");
89 p_tanh = (void *)GetProcAddress(hmod, "tanh");
90 p_lfind_s = (void *)GetProcAddress(hmod, "_lfind_s");
91 }
92
test_rand_s(void)93 static void test_rand_s(void)
94 {
95 int ret;
96 unsigned int rand;
97
98 if (!prand_s)
99 {
100 win_skip("rand_s is not available\n");
101 return;
102 }
103
104 errno = EBADF;
105 ret = prand_s(NULL);
106 ok(ret == EINVAL, "Expected rand_s to return EINVAL, got %d\n", ret);
107 ok(errno == EINVAL, "Expected errno to return EINVAL, got %d\n", errno);
108
109 ret = prand_s(&rand);
110 ok(ret == 0, "Expected rand_s to return 0, got %d\n", ret);
111 }
112
113 typedef struct _I10_OUTPUT_data {
114 short pos;
115 char sign;
116 BYTE len;
117 char str[100];
118 } I10_OUTPUT_data;
119
120 typedef struct _I10_OUTPUT_test {
121 struct uld d;
122 int size;
123 int flags;
124
125 I10_OUTPUT_data out;
126 int ret;
127 const char *remain;
128 } I10_OUTPUT_test;
129
130 static const I10_OUTPUT_test I10_OUTPUT_tests[] = {
131 /* arg3 = 0 */
132 { { 0x00000000, 0x00000000, 0x0000 /* 0.0 */ }, 10, 0, {0, ' ', 1, "0"}, 1, "" },
133 { { 0x00000000, 0x80000000, 0x3fff /* 1.0 */ }, 10, 0, {1, ' ', 1, "1"}, 1, "000000009" },
134 { { 0x00000000, 0x80000000, 0xbfff /* -1.0 */ }, 10, 0, {1, '-', 1, "1"}, 1, "000000009" },
135 { { 0x0a3d7000, 0x9d70a3d7, 0x3fff /* 1.23 */ }, 10, 0, {1, ' ', 3, "123"}, 1, "0000009" },
136 { { 0x00000000, 0x9184e72a, 0x402a /* 1e13 */ }, 10, 0, {14, ' ', 1, "1"}, 1, "000000009" },
137 { { 0x04675000, 0xc9f2c9cd, 0x4062 /* 1e30 */ }, 30, 0, {31, ' ', 21, "100000000000000001988"}, 1, "" },
138 { { 0x4bb41000, 0xe12e1342, 0x3fd3 /* 1e-13 */ }, 10, 0, {-12, ' ', 1, "1"}, 1, "000000000" },
139 { { 0x00000000, 0x80000000, 0x3ffd /* 0.25 */ }, 10, 0, {0, ' ', 2, "25"}, 1, "00000000" },
140 { { 0xbf94d800, 0x800000d6, 0x3fff /* 1.0000001 */ }, 10, 0, {1, ' ', 8, "10000001"}, 1, "00" },
141 { { 0x00000000, 0x80000000, 0x7fff /* +inf */ }, 10, 0, {1, ' ', 5, "1#INF"}, 0, "" },
142 { { 0x00000000, 0x80000000, 0xffff /* -inf */ }, 10, 0, {1, '-', 5, "1#INF"}, 0, "" },
143 { { 0x00000001, 0x80000000, 0x7fff /* snan */ }, 10, 0, {1, ' ', 6, "1#SNAN"}, 0, "" },
144 { { 0x00000001, 0x80000000, 0xffff /* snan */ }, 10, 0, {1, '-', 6, "1#SNAN"}, 0, "" },
145 { { 0x00000000, 0xc0000000, 0x7fff /* qnan */ }, 10, 0, {1, ' ', 6, "1#QNAN"}, 0, "" },
146 { { 0x00000000, 0x40000000, 0xffff /* qnan */ }, 10, 0, {1, '-', 6, "1#QNAN"}, 0, "" },
147 /* arg3 = 1 */
148 { { 0x00000000, 0x00000000, 0x0000 /* 0 */ }, 10, 1, {0, ' ', 1, "0"}, 1, "" },
149 { { 0x00000000, 0x80000000, 0x3fff /* 1 */ }, 10, 1, {1, ' ', 1, "1"}, 1, "0000000009" },
150 { { 0x00000000, 0x80000000, 0xbfff /* -1 */ }, 10, 1, {1, '-', 1, "1"}, 1, "0000000009" },
151 { { 0x0a3d7000, 0x9d70a3d7, 0x3fff /* 1.23 */ }, 10, 1, {1, ' ', 3, "123"}, 1, "00000009" },
152 { { 0x00000000, 0x9184e72a, 0x402a /* 1e13 */ }, 10, 1, {14, ' ', 1, "1"}, 1, "00000000000000000009" },
153 { { 0x04675000, 0xc9f2c9cd, 0x4062 /* 1e30 */ }, 30, 1, {31, ' ', 21, "100000000000000001988"}, 1, "" },
154 { { 0x4bb41000, 0xe12e1342, 0x3fd3 /* 1e-13 */ }, 10, 1, {0, ' ', 1, "0"}, 1, "" },
155 { { 0xe57a4000, 0xd6bf94d5, 0x3fe7 /* 1e-7 */ }, 10, 1, {-6, ' ', 1, "1"}, 1, "09" },
156 { { 0x00000000, 0x80000000, 0x3ffd /* 0.25 */ }, 10, 1, {0, ' ', 2, "25"}, 1, "00000000" },
157 { { 0xbf94d800, 0x800000d6, 0x3fff /* 1.0000001 */ }, 10, 1, {1, ' ', 8, "10000001"}, 1, "000" },
158 { { 0x00000000, 0x80000000, 0x7fff /* +inf */ }, 10, 1, {1, ' ', 5, "1#INF"}, 0, "" },
159 { { 0x00000000, 0x80000000, 0xffff /* -inf */ }, 10, 1, {1, '-', 5, "1#INF"}, 0, "" },
160 { { 0x00000001, 0x80000000, 0x7fff /* snan */ }, 10, 1, {1, ' ', 6, "1#SNAN"}, 0, "" },
161 { { 0x00000000, 0xc0000000, 0x7fff /* qnan */ }, 10, 1, {1, ' ', 6, "1#QNAN"}, 0, "" },
162 { { 0x00000000, 0x40000000, 0x7fff /* qnan */ }, 10, 1, {1, ' ', 6, "1#QNAN"}, 0, "" },
163 /* too small buffer */
164 { { 0x00000000, 0x00000000, 0x0000 /* 0 */ }, 0, 0, {0, ' ', 1, "0"}, 1, "" },
165 { { 0x00000000, 0x00000000, 0x0000 /* 0 */ }, 0, 1, {0, ' ', 1, "0"}, 1, "" },
166 { { 0x00000000, 0xf6000000, 0x4005 /* 123 */ }, 2, 0, {3, ' ', 2, "12"}, 1, "" },
167 { { 0x00000000, 0xf6000000, 0x4005 /* 123 */ }, 0, 0, {0, ' ', 1, "0"}, 1, "" },
168 { { 0x00000000, 0xf6000000, 0x4005 /* 123 */ }, 2, 1, {3, ' ', 3, "123"}, 1, "09" },
169 { { 0x0a3d7000, 0xfd70a3d7, 0x3ffe /* 0.99 */ }, 1, 0, {1, ' ', 1, "1"}, 1, "" },
170 { { 0x00000000, 0x9a5db800, 0x4013 /* 1264567.0 */ }, 2, 0, {7, ' ', 2, "13"}, 1, "" },
171 { { 0x00000000, 0x9a5db800, 0x4013 /* 1264567.0 */ }, 2, 1, {7, ' ', 7, "1264567"}, 1, "00" },
172 { { 0x00000000, 0x932c05a6, 0x401d /* 1234567891.0 */ }, 2, 1, {10, ' ', 10, "1234567891"}, 1, "09" }
173 };
174
test_I10_OUTPUT(void)175 static void test_I10_OUTPUT(void)
176 {
177 I10_OUTPUT_data out;
178 int i, j, ret;
179
180 if(!pI10_OUTPUT) {
181 win_skip("I10_OUTPUT not available\n");
182 return;
183 }
184
185 for(i=0; i<ARRAY_SIZE(I10_OUTPUT_tests); i++) {
186 memset(out.str, '#', sizeof(out.str));
187 ret = pI10_OUTPUT(I10_OUTPUT_tests[i].d, I10_OUTPUT_tests[i].size, I10_OUTPUT_tests[i].flags, &out);
188 ok(ret == I10_OUTPUT_tests[i].ret, "%d: ret = %d\n", i, ret);
189 ok(out.pos == I10_OUTPUT_tests[i].out.pos, "%d: out.pos = %hd\n", i, out.pos);
190 ok(out.sign == I10_OUTPUT_tests[i].out.sign, "%d: out.size = %c\n", i, out.sign);
191 ok(out.len == I10_OUTPUT_tests[i].out.len, "%d: out.len = %d\n", i, (int)out.len);
192 ok(!strcmp(out.str, I10_OUTPUT_tests[i].out.str), "%d: out.str = %s\n", i, out.str);
193
194 j = strlen(I10_OUTPUT_tests[i].remain);
195 todo_wine_if(j && I10_OUTPUT_tests[i].remain[j-1]=='9')
196 ok(!strncmp(out.str+out.len+1, I10_OUTPUT_tests[i].remain, j),
197 "%d: &out.str[%d] = %.25s...\n", i, out.len+1, out.str+out.len+1);
198
199 for(j=out.len+strlen(I10_OUTPUT_tests[i].remain)+1; j<sizeof(out.str); j++)
200 if(out.str[j] != '#')
201 ok(0, "%d: out.str[%d] = %c (expected \'#\')\n", i, j, out.str[j]);
202 }
203 }
204
test_strerror_s(void)205 static void test_strerror_s(void)
206 {
207 int ret;
208 char buf[256];
209
210 if (!pstrerror_s)
211 {
212 win_skip("strerror_s is not available\n");
213 return;
214 }
215
216 errno = EBADF;
217 ret = pstrerror_s(NULL, 0, 0);
218 ok(ret == EINVAL, "Expected strerror_s to return EINVAL, got %d\n", ret);
219 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
220
221 errno = EBADF;
222 ret = pstrerror_s(NULL, sizeof(buf), 0);
223 ok(ret == EINVAL, "Expected strerror_s to return EINVAL, got %d\n", ret);
224 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
225
226 memset(buf, 'X', sizeof(buf));
227 errno = EBADF;
228 ret = pstrerror_s(buf, 0, 0);
229 ok(ret == EINVAL, "Expected strerror_s to return EINVAL, got %d\n", ret);
230 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
231 ok(buf[0] == 'X', "Expected output buffer to be untouched\n");
232
233 memset(buf, 'X', sizeof(buf));
234 ret = pstrerror_s(buf, 1, 0);
235 ok(ret == 0, "Expected strerror_s to return 0, got %d\n", ret);
236 ok(strlen(buf) == 0, "Expected output buffer to be null terminated\n");
237
238 memset(buf, 'X', sizeof(buf));
239 ret = pstrerror_s(buf, 2, 0);
240 ok(ret == 0, "Expected strerror_s to return 0, got %d\n", ret);
241 ok(strlen(buf) == 1, "Expected output buffer to be truncated\n");
242
243 memset(buf, 'X', sizeof(buf));
244 ret = pstrerror_s(buf, sizeof(buf), 0);
245 ok(ret == 0, "Expected strerror_s to return 0, got %d\n", ret);
246
247 memset(buf, 'X', sizeof(buf));
248 ret = pstrerror_s(buf, sizeof(buf), -1);
249 ok(ret == 0, "Expected strerror_s to return 0, got %d\n", ret);
250 }
251
test__get_doserrno(void)252 static void test__get_doserrno(void)
253 {
254 int ret, out;
255
256 if (!p_get_doserrno)
257 {
258 win_skip("_get_doserrno is not available\n");
259 return;
260 }
261
262 _doserrno = ERROR_INVALID_CMM;
263 errno = EBADF;
264 ret = p_get_doserrno(NULL);
265 ok(ret == EINVAL, "Expected _get_doserrno to return EINVAL, got %d\n", ret);
266 ok(_doserrno == ERROR_INVALID_CMM, "Expected _doserrno to be ERROR_INVALID_CMM, got %d\n", _doserrno);
267 ok(errno == EBADF, "Expected errno to be EBADF, got %d\n", errno);
268
269 _doserrno = ERROR_INVALID_CMM;
270 errno = EBADF;
271 out = 0xdeadbeef;
272 ret = p_get_doserrno(&out);
273 ok(ret == 0, "Expected _get_doserrno to return 0, got %d\n", ret);
274 ok(out == ERROR_INVALID_CMM, "Expected output variable to be ERROR_INVALID_CMM, got %d\n", out);
275 }
276
test__get_errno(void)277 static void test__get_errno(void)
278 {
279 int ret, out;
280
281 if (!p_get_errno)
282 {
283 win_skip("_get_errno is not available\n");
284 return;
285 }
286
287 errno = EBADF;
288 ret = p_get_errno(NULL);
289 ok(ret == EINVAL, "Expected _get_errno to return EINVAL, got %d\n", ret);
290 ok(errno == EBADF, "Expected errno to be EBADF, got %d\n", errno);
291
292 errno = EBADF;
293 out = 0xdeadbeef;
294 ret = p_get_errno(&out);
295 ok(ret == 0, "Expected _get_errno to return 0, got %d\n", ret);
296 ok(out == EBADF, "Expected output variable to be EBADF, got %d\n", out);
297 }
298
test__set_doserrno(void)299 static void test__set_doserrno(void)
300 {
301 int ret;
302
303 if (!p_set_doserrno)
304 {
305 win_skip("_set_doserrno is not available\n");
306 return;
307 }
308
309 _doserrno = ERROR_INVALID_CMM;
310 ret = p_set_doserrno(ERROR_FILE_NOT_FOUND);
311 ok(ret == 0, "Expected _set_doserrno to return 0, got %d\n", ret);
312 ok(_doserrno == ERROR_FILE_NOT_FOUND,
313 "Expected _doserrno to be ERROR_FILE_NOT_FOUND, got %d\n", _doserrno);
314
315 _doserrno = ERROR_INVALID_CMM;
316 ret = p_set_doserrno(-1);
317 ok(ret == 0, "Expected _set_doserrno to return 0, got %d\n", ret);
318 ok(_doserrno == -1,
319 "Expected _doserrno to be -1, got %d\n", _doserrno);
320
321 _doserrno = ERROR_INVALID_CMM;
322 ret = p_set_doserrno(0xdeadbeef);
323 ok(ret == 0, "Expected _set_doserrno to return 0, got %d\n", ret);
324 ok(_doserrno == 0xdeadbeef,
325 "Expected _doserrno to be 0xdeadbeef, got %d\n", _doserrno);
326 }
327
test__set_errno(void)328 static void test__set_errno(void)
329 {
330 int ret;
331
332 if (!p_set_errno)
333 {
334 win_skip("_set_errno is not available\n");
335 return;
336 }
337
338 errno = EBADF;
339 ret = p_set_errno(EINVAL);
340 ok(ret == 0, "Expected _set_errno to return 0, got %d\n", ret);
341 ok(errno == EINVAL, "Expected errno to be EINVAL, got %d\n", errno);
342
343 errno = EBADF;
344 ret = p_set_errno(-1);
345 ok(ret == 0, "Expected _set_errno to return 0, got %d\n", ret);
346 ok(errno == -1, "Expected errno to be -1, got %d\n", errno);
347
348 errno = EBADF;
349 ret = p_set_errno(0xdeadbeef);
350 ok(ret == 0, "Expected _set_errno to return 0, got %d\n", ret);
351 ok(errno == 0xdeadbeef, "Expected errno to be 0xdeadbeef, got %d\n", errno);
352 }
353
test__popen_child(void)354 static void test__popen_child(void)
355 {
356 /* don't execute any tests here */
357 /* ExitProcess is used to set return code of _pclose */
358 printf("child output\n");
359 ExitProcess(0x37);
360 }
361
test__popen(const char * name)362 static void test__popen(const char *name)
363 {
364 FILE *pipe;
365 char buf[1024];
366 int ret;
367
368 sprintf(buf, "\"%s\" misc popen", name);
369 pipe = _popen(buf, "r");
370 ok(pipe != NULL, "_popen failed with error: %d\n", errno);
371
372 fgets(buf, sizeof(buf), pipe);
373 ok(!strcmp(buf, "child output\n"), "buf = %s\n", buf);
374
375 ret = _pclose(pipe);
376 ok(ret == 0x37, "_pclose returned %x, expected 0x37\n", ret);
377
378 errno = 0xdeadbeef;
379 ret = _pclose((FILE*)0xdeadbeef);
380 ok(ret == -1, "_pclose returned %x, expected -1\n", ret);
381 if(p_set_errno)
382 ok(errno == EBADF, "errno = %d\n", errno);
383 }
384
test__invalid_parameter(void)385 static void test__invalid_parameter(void)
386 {
387 if(!p__invalid_parameter) {
388 win_skip("_invalid_parameter not available\n");
389 return;
390 }
391
392 p__invalid_parameter(NULL, NULL, NULL, 0, 0);
393 }
394
395 struct qsort_test
396 {
397 int pos;
398 int *base;
399
400 struct {
401 int l;
402 int r;
403 } cmp[64];
404 };
405
qsort_comp(void * ctx,const void * l,const void * r)406 static int __cdecl qsort_comp(void *ctx, const void *l, const void *r)
407 {
408 struct qsort_test *qt = ctx;
409
410 if(qt) {
411 ok(qt->pos < 64, "qt->pos = %d\n", qt->pos);
412 ok(qt->cmp[qt->pos].l == (int*)l-qt->base,
413 "%d) l on %ld position\n", qt->pos, (long)((int*)l - qt->base));
414 ok(qt->cmp[qt->pos].r == (int*)r-qt->base,
415 "%d) r on %ld position\n", qt->pos, (long)((int*)r - qt->base));
416 qt->pos++;
417 }
418
419 return *(int*)l%1000 - *(int*)r%1000;
420 }
421
test_qsort_s(void)422 static void test_qsort_s(void)
423 {
424 static const int nonstable_test[] = {9000, 8001, 7002, 6003, 1003, 5004, 4005, 3006, 2007};
425 int tab[100], i;
426
427 struct qsort_test small_sort = {
428 0, tab, {
429 {1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 5}, {7, 6},
430 {1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 5},
431 {1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4},
432 {1, 0}, {2, 1}, {3, 2}, {4, 3},
433 {1, 0}, {2, 1}, {3, 2},
434 {1, 0}, {2, 1},
435 {1, 0}
436 }
437 }, small_sort2 = {
438 0, tab, {
439 {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}, {7, 0},
440 {1, 0}, {2, 1}, {3, 1}, {4, 1}, {5, 1}, {6, 1},
441 {1, 0}, {2, 1}, {3, 2}, {4, 2}, {5, 2},
442 {1, 0}, {2, 1}, {3, 2}, {4, 3},
443 {1, 0}, {2, 1}, {3, 2},
444 {1, 0}, {2, 1},
445 {1, 0}
446 }
447 }, quick_sort = {
448 0, tab, {
449 {0, 4}, {0, 8}, {4, 8},
450 {1, 4}, {2, 4}, {3, 4}, {5, 4}, {6, 4}, {7, 4}, {7, 4}, {6, 4},
451 {6, 4},
452 {8, 7},
453 {1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}, {6, 4},
454 {1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 3},
455 {1, 0}, {2, 1}, {3, 2}, {4, 2},
456 {1, 0}, {2, 1}, {3, 2},
457 {1, 0}, {2, 1},
458 {1, 0}
459 }
460 };
461
462 if(!p_qsort_s) {
463 win_skip("qsort_s not available\n");
464 return;
465 }
466
467 for(i=0; i<8; i++) tab[i] = i;
468 p_qsort_s(tab, 8, sizeof(int), qsort_comp, &small_sort);
469 ok(small_sort.pos == 28, "small_sort.pos = %d\n", small_sort.pos);
470 for(i=0; i<8; i++)
471 ok(tab[i] == i, "tab[%d] = %d\n", i, tab[i]);
472
473 for(i=0; i<8; i++) tab[i] = 7-i;
474 p_qsort_s(tab, 8, sizeof(int), qsort_comp, &small_sort2);
475 ok(small_sort2.pos == 28, "small_sort2.pos = %d\n", small_sort2.pos);
476 for(i=0; i<8; i++)
477 ok(tab[i] == i, "tab[%d] = %d\n", i, tab[i]);
478
479 for(i=0; i<9; i++) tab[i] = i;
480 tab[5] = 1;
481 tab[6] = 2;
482 p_qsort_s(tab, 9, sizeof(int), qsort_comp, &quick_sort);
483 ok(quick_sort.pos == 34, "quick_sort.pos = %d\n", quick_sort.pos);
484
485 /* show that qsort is not stable */
486 for(i=0; i<9; i++) tab[i] = 8-i + 1000*(i+1);
487 tab[0] = 1003;
488 p_qsort_s(tab, 9, sizeof(int), qsort_comp, NULL);
489 for(i=0; i<9; i++)
490 ok(tab[i] == nonstable_test[i], "tab[%d] = %d, expected %d\n", i, tab[i], nonstable_test[i]);
491
492 /* check if random data is sorted */
493 srand(0);
494 for(i=0; i<100; i++) tab[i] = rand()%1000;
495 p_qsort_s(tab, 100, sizeof(int), qsort_comp, NULL);
496 for(i=1; i<100; i++)
497 ok(tab[i-1] <= tab[i], "data sorted incorrectly on position %d: %d <= %d\n", i, tab[i-1], tab[i]);
498
499 /* test if random permutation is sorted correctly */
500 for(i=0; i<100; i++) tab[i] = i;
501 for(i=0; i<100; i++) {
502 int b = rand()%100;
503 int e = rand()%100;
504
505 if(b == e) continue;
506 tab[b] ^= tab[e];
507 tab[e] ^= tab[b];
508 tab[b] ^= tab[e];
509 }
510 p_qsort_s(tab, 100, sizeof(int), qsort_comp, NULL);
511 for(i=0; i<100; i++)
512 ok(tab[i] == i, "data sorted incorrectly on position %d: %d\n", i, tab[i]);
513 }
514
test_math_functions(void)515 static void test_math_functions(void)
516 {
517 double ret;
518
519 errno = 0xdeadbeef;
520 p_atan(NAN);
521 ok(errno == EDOM, "errno = %d\n", errno);
522
523 errno = 0xdeadbeef;
524 ret = p_atan(INFINITY);
525 ok(almost_equal(ret, 1.57079632679489661923), "ret = %lf\n", ret);
526 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
527
528 errno = 0xdeadbeef;
529 ret = p_atan(-INFINITY);
530 ok(almost_equal(ret, -1.57079632679489661923), "ret = %lf\n", ret);
531 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
532
533 errno = 0xdeadbeef;
534 p_tanh(NAN);
535 ok(errno == EDOM, "errno = %d\n", errno);
536
537 errno = 0xdeadbeef;
538 ret = p_tanh(INFINITY);
539 ok(almost_equal(ret, 1.0), "ret = %lf\n", ret);
540 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
541
542 errno = 0xdeadbeef;
543 p_exp(NAN);
544 ok(errno == EDOM, "errno = %d\n", errno);
545
546 errno = 0xdeadbeef;
547 p_exp(INFINITY);
548 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
549 }
550
test_thread_func(void * end_thread_type)551 static void __cdecl test_thread_func(void *end_thread_type)
552 {
553 if (end_thread_type == (void*)1)
554 _endthread();
555 else if (end_thread_type == (void*)2)
556 ExitThread(0);
557 else if (end_thread_type == (void*)3)
558 _endthreadex(0);
559 }
560
test_thread_func_ex(void * arg)561 static unsigned __stdcall test_thread_func_ex(void *arg)
562 {
563 _endthread();
564 return 0;
565 }
566
test_thread_handle_close(void)567 static void test_thread_handle_close(void)
568 {
569 HANDLE hThread;
570 DWORD ret;
571
572 /* _beginthread: handle is not closed on ExitThread and _endthreadex */
573 hThread = (HANDLE)_beginthread(test_thread_func, 0, NULL);
574 ok(hThread != INVALID_HANDLE_VALUE, "_beginthread failed (%d)\n", errno);
575 WaitForSingleObject(hThread, INFINITE);
576 ret = CloseHandle(hThread);
577 ok(!ret, "ret = %d\n", ret);
578
579 hThread = (HANDLE)_beginthread(test_thread_func, 0, (void*)1);
580 ok(hThread != INVALID_HANDLE_VALUE, "_beginthread failed (%d)\n", errno);
581 WaitForSingleObject(hThread, INFINITE);
582 ret = CloseHandle(hThread);
583 ok(!ret, "ret = %d\n", ret);
584
585 hThread = (HANDLE)_beginthread(test_thread_func, 0, (void*)2);
586 ok(hThread != INVALID_HANDLE_VALUE, "_beginthread failed (%d)\n", errno);
587 Sleep(150);
588 ret = WaitForSingleObject(hThread, INFINITE);
589 ok(ret == WAIT_OBJECT_0, "ret = %d\n", ret);
590 ret = CloseHandle(hThread);
591 ok(ret, "ret = %d\n", ret);
592
593 hThread = (HANDLE)_beginthread(test_thread_func, 0, (void*)3);
594 ok(hThread != INVALID_HANDLE_VALUE, "_beginthread failed (%d)\n", errno);
595 Sleep(150);
596 ret = WaitForSingleObject(hThread, INFINITE);
597 ok(ret == WAIT_OBJECT_0, "ret = %d\n", ret);
598 ret = CloseHandle(hThread);
599 ok(ret, "ret = %d\n", ret);
600
601 /* _beginthreadex: handle is not closed on _endthread */
602 hThread = (HANDLE)_beginthreadex(NULL,0, test_thread_func_ex, NULL, 0, NULL);
603 ok(hThread != NULL, "_beginthreadex failed (%d)\n", errno);
604 Sleep(150);
605 ret = WaitForSingleObject(hThread, INFINITE);
606 ok(ret == WAIT_OBJECT_0, "ret = %d\n", ret);
607 ret = CloseHandle(hThread);
608 ok(ret, "ret = %d\n", ret);
609 }
610
_lfind_s_comp(void * ctx,const void * l,const void * r)611 static int __cdecl _lfind_s_comp(void *ctx, const void *l, const void *r)
612 {
613 *(int *)ctx = 0xdeadc0de;
614 return *(int *)l - *(int *)r;
615 }
616
test__lfind_s(void)617 static void test__lfind_s(void)
618 {
619 static const int tests[] = {9000, 8001, 7002, 6003, 1003, 5004, 4005, 3006, 2007};
620 unsigned int num;
621 void *found;
622 int ctx;
623 int key;
624
625 if (!p_lfind_s)
626 {
627 win_skip("_lfind_s is not available\n");
628 return;
629 }
630
631 key = 1234;
632 num = ARRAY_SIZE(tests);
633
634 errno = 0xdeadbeef;
635 found = p_lfind_s(NULL, tests, &num, sizeof(int), _lfind_s_comp, NULL);
636 ok(errno == EINVAL, "errno = %d\n", errno);
637 ok(!found, "Expected NULL, got %p\n", found);
638
639 errno = 0xdeadbeef;
640 found = p_lfind_s(&key, NULL, &num, sizeof(int), _lfind_s_comp, NULL);
641 ok(errno == EINVAL, "errno = %d\n", errno);
642 ok(!found, "Expected NULL, got %p\n", found);
643
644 errno = 0xdeadbeef;
645 found = p_lfind_s(&key, tests, &num, 0, _lfind_s_comp, NULL);
646 ok(errno == EINVAL, "errno = %d\n", errno);
647 ok(!found, "Expected NULL, got %p\n", found);
648
649 errno = 0xdeadbeef;
650 found = p_lfind_s(&key, tests, &num, sizeof(int), NULL, NULL);
651 ok(errno == EINVAL, "errno = %d\n", errno);
652 ok(!found, "Expected NULL, got %p\n", found);
653
654 ctx = -1;
655 key = 9000;
656 errno = 0xdeadbeef;
657 found = p_lfind_s(&key, tests, &num, sizeof(int), _lfind_s_comp, &ctx);
658 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
659 ok(found == tests, "Expected %p, got %p\n", tests, found);
660 ok(ctx == 0xdeadc0de, "Expected 0xdeadc0de, got %x\n", ctx);
661
662 ctx = -1;
663 key = 2007;
664 errno = 0xdeadbeef;
665 found = p_lfind_s(&key, tests, &num, sizeof(int), _lfind_s_comp, &ctx);
666 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
667 ok(found == tests+8, "Expected %p, got %p\n", tests+8, found);
668 ok(ctx == 0xdeadc0de, "Expected 0xdeadc0de, got %x\n", ctx);
669
670 ctx = -1;
671 key = 1234;
672 errno = 0xdeadbeef;
673 found = p_lfind_s(&key, tests, &num, sizeof(int), _lfind_s_comp, &ctx);
674 ok(errno == 0xdeadbeef, "errno = %d\n", errno);
675 ok(!found, "Expected NULL, got %p\n", found);
676 ok(ctx == 0xdeadc0de, "Expected 0xdeadc0de, got %x\n", ctx);
677 }
678
START_TEST(misc)679 START_TEST(misc)
680 {
681 int arg_c;
682 char** arg_v;
683
684 init();
685
686 arg_c = winetest_get_mainargs(&arg_v);
687 if(arg_c >= 3) {
688 if(!strcmp(arg_v[2], "popen"))
689 test__popen_child();
690 else
691 ok(0, "invalid argument '%s'\n", arg_v[2]);
692
693 return;
694 }
695
696 test_rand_s();
697 test_I10_OUTPUT();
698 test_strerror_s();
699 test__get_doserrno();
700 test__get_errno();
701 test__set_doserrno();
702 test__set_errno();
703 test__popen(arg_v[0]);
704 test__invalid_parameter();
705 test_qsort_s();
706 test_math_functions();
707 test_thread_handle_close();
708 test__lfind_s();
709 }
710