ReactOS 0.4.15-dev-5667-ged97270
string.c
Go to the documentation of this file.
1/* Unit test suite for string functions and some wcstring functions
2 *
3 * Copyright 2003 Thomas Mertes
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 * NOTES
20 * We use function pointers here as there is no import library for NTDLL on
21 * windows.
22 */
23
24#include <stdlib.h>
25
26#include "ntdll_test.h"
27
28
29/* Function ptrs for ntdll calls */
30static HMODULE hntdll = 0;
31static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
32static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);
33static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING,LPCSTR);
34static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
35
36static int (WINAPIV *patoi)(const char *);
37static long (WINAPIV *patol)(const char *);
38static LONGLONG (WINAPIV *p_atoi64)(const char *);
39static LPSTR (WINAPIV *p_itoa)(int, LPSTR, INT);
40static LPSTR (WINAPIV *p_ltoa)(LONG, LPSTR, INT);
41static LPSTR (WINAPIV *p_ultoa)(ULONG, LPSTR, INT);
42static LPSTR (WINAPIV *p_i64toa)(LONGLONG, LPSTR, INT);
43static LPSTR (WINAPIV *p_ui64toa)(ULONGLONG, LPSTR, INT);
44
45static int (WINAPIV *p_wtoi)(LPWSTR);
46static long (WINAPIV *p_wtol)(LPWSTR);
47static LONGLONG (WINAPIV *p_wtoi64)(LPWSTR);
48static LPWSTR (WINAPIV *p_itow)(int, LPWSTR, int);
49static LPWSTR (WINAPIV *p_ltow)(LONG, LPWSTR, INT);
50static LPWSTR (WINAPIV *p_ultow)(ULONG, LPWSTR, INT);
51static LPWSTR (WINAPIV *p_i64tow)(LONGLONG, LPWSTR, INT);
52static LPWSTR (WINAPIV *p_ui64tow)(ULONGLONG, LPWSTR, INT);
53
54static LPWSTR (__cdecl *p_wcslwr)(LPWSTR);
55static LPWSTR (__cdecl *p_wcsupr)(LPWSTR);
56
57static LPWSTR (WINAPIV *p_wcschr)(LPCWSTR, WCHAR);
58static LPWSTR (WINAPIV *p_wcsrchr)(LPCWSTR, WCHAR);
59
60static void (__cdecl *p_qsort)(void *,size_t,size_t, int(__cdecl *compar)(const void *, const void *) );
61static void* (__cdecl *p_bsearch)(void *,void*,size_t,size_t, int(__cdecl *compar)(const void *, const void *) );
62static int (WINAPIV *p__snprintf)(char *, size_t, const char *, ...);
63
64
65static void InitFunctionPtrs(void)
66{
67 hntdll = LoadLibraryA("ntdll.dll");
68 ok(hntdll != 0, "LoadLibrary failed\n");
69 if (hntdll) {
70 pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
71 pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
72 pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
73 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
74
75 patoi = (void *)GetProcAddress(hntdll, "atoi");
76 patol = (void *)GetProcAddress(hntdll, "atol");
77 p_atoi64 = (void *)GetProcAddress(hntdll, "_atoi64");
78 p_itoa = (void *)GetProcAddress(hntdll, "_itoa");
79 p_ltoa = (void *)GetProcAddress(hntdll, "_ltoa");
80 p_ultoa = (void *)GetProcAddress(hntdll, "_ultoa");
81 p_i64toa = (void *)GetProcAddress(hntdll, "_i64toa");
82 p_ui64toa = (void *)GetProcAddress(hntdll, "_ui64toa");
83
84 p_wtoi = (void *)GetProcAddress(hntdll, "_wtoi");
85 p_wtol = (void *)GetProcAddress(hntdll, "_wtol");
86 p_wtoi64 = (void *)GetProcAddress(hntdll, "_wtoi64");
87 p_itow = (void *)GetProcAddress(hntdll, "_itow");
88 p_ltow = (void *)GetProcAddress(hntdll, "_ltow");
89 p_ultow = (void *)GetProcAddress(hntdll, "_ultow");
90 p_i64tow = (void *)GetProcAddress(hntdll, "_i64tow");
91 p_ui64tow = (void *)GetProcAddress(hntdll, "_ui64tow");
92
93 p_wcslwr = (void *)GetProcAddress(hntdll, "_wcslwr");
94 p_wcsupr = (void *)GetProcAddress(hntdll, "_wcsupr");
95
96 p_wcschr= (void *)GetProcAddress(hntdll, "wcschr");
97 p_wcsrchr= (void *)GetProcAddress(hntdll, "wcsrchr");
98 p_qsort= (void *)GetProcAddress(hntdll, "qsort");
99 p_bsearch= (void *)GetProcAddress(hntdll, "bsearch");
100
101 p__snprintf = (void *)GetProcAddress(hntdll, "_snprintf");
102 } /* if */
103}
104
105
106#define LARGE_STRI_BUFFER_LENGTH 67
107
108typedef struct {
109 int base;
111 const char *Buffer;
112 int mask; /* ntdll/msvcrt: 0x01=itoa, 0x02=ltoa, 0x04=ultoa */
113 /* 0x10=itow, 0x20=ltow, 0x40=ultow */
115
116static const ulong2str_t ulong2str[] = {
117 {10, 123, "123\0---------------------------------------------------------------", 0x77},
118
119 { 2, 0x80000000U, "10000000000000000000000000000000\0----------------------------------", 0x67},
120 { 2, -2147483647, "10000000000000000000000000000001\0----------------------------------", 0x67},
121 { 2, -65537, "11111111111111101111111111111111\0----------------------------------", 0x67},
122 { 2, -65536, "11111111111111110000000000000000\0----------------------------------", 0x67},
123 { 2, -65535, "11111111111111110000000000000001\0----------------------------------", 0x67},
124 { 2, -32768, "11111111111111111000000000000000\0----------------------------------", 0x67},
125 { 2, -32767, "11111111111111111000000000000001\0----------------------------------", 0x67},
126 { 2, -2, "11111111111111111111111111111110\0----------------------------------", 0x67},
127 { 2, -1, "11111111111111111111111111111111\0----------------------------------", 0x67},
128 { 2, 0, "0\0-----------------------------------------------------------------", 0x77},
129 { 2, 1, "1\0-----------------------------------------------------------------", 0x77},
130 { 2, 10, "1010\0--------------------------------------------------------------", 0x77},
131 { 2, 100, "1100100\0-----------------------------------------------------------", 0x77},
132 { 2, 1000, "1111101000\0--------------------------------------------------------", 0x77},
133 { 2, 10000, "10011100010000\0----------------------------------------------------", 0x77},
134 { 2, 32767, "111111111111111\0---------------------------------------------------", 0x77},
135 { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x77},
136 { 2, 65535, "1111111111111111\0--------------------------------------------------", 0x77},
137 { 2, 100000, "11000011010100000\0-------------------------------------------------", 0x77},
138 { 2, 234567, "111001010001000111\0------------------------------------------------", 0x77},
139 { 2, 300000, "1001001001111100000\0-----------------------------------------------", 0x77},
140 { 2, 524287, "1111111111111111111\0-----------------------------------------------", 0x77},
141 { 2, 524288, "10000000000000000000\0----------------------------------------------", 0x67},
142 { 2, 1000000, "11110100001001000000\0----------------------------------------------", 0x67},
143 { 2, 10000000, "100110001001011010000000\0------------------------------------------", 0x67},
144 { 2, 100000000, "101111101011110000100000000\0---------------------------------------", 0x67},
145 { 2, 1000000000, "111011100110101100101000000000\0------------------------------------", 0x67},
146 { 2, 1073741823, "111111111111111111111111111111\0------------------------------------", 0x67},
147 { 2, 2147483646, "1111111111111111111111111111110\0-----------------------------------", 0x67},
148 { 2, 2147483647, "1111111111111111111111111111111\0-----------------------------------", 0x67},
149 { 2, 2147483648U, "10000000000000000000000000000000\0----------------------------------", 0x67},
150 { 2, 2147483649U, "10000000000000000000000000000001\0----------------------------------", 0x67},
151 { 2, 4294967294U, "11111111111111111111111111111110\0----------------------------------", 0x67},
152 { 2, 0xFFFFFFFF, "11111111111111111111111111111111\0----------------------------------", 0x67},
153
154 { 8, 0x80000000U, "20000000000\0-------------------------------------------------------", 0x77},
155 { 8, -2147483647, "20000000001\0-------------------------------------------------------", 0x77},
156 { 8, -2, "37777777776\0-------------------------------------------------------", 0x77},
157 { 8, -1, "37777777777\0-------------------------------------------------------", 0x77},
158 { 8, 0, "0\0-----------------------------------------------------------------", 0x77},
159 { 8, 1, "1\0-----------------------------------------------------------------", 0x77},
160 { 8, 2147483646, "17777777776\0-------------------------------------------------------", 0x77},
161 { 8, 2147483647, "17777777777\0-------------------------------------------------------", 0x77},
162 { 8, 2147483648U, "20000000000\0-------------------------------------------------------", 0x77},
163 { 8, 2147483649U, "20000000001\0-------------------------------------------------------", 0x77},
164 { 8, 4294967294U, "37777777776\0-------------------------------------------------------", 0x77},
165 { 8, 4294967295U, "37777777777\0-------------------------------------------------------", 0x77},
166
167 {10, 0x80000000U, "-2147483648\0-------------------------------------------------------", 0x33},
168 {10, 0x80000000U, "2147483648\0--------------------------------------------------------", 0x44},
169 {10, -2147483647, "-2147483647\0-------------------------------------------------------", 0x33},
170 {10, -2147483647, "2147483649\0--------------------------------------------------------", 0x44},
171 {10, -2, "-2\0----------------------------------------------------------------", 0x33},
172 {10, -2, "4294967294\0--------------------------------------------------------", 0x44},
173 {10, -1, "-1\0----------------------------------------------------------------", 0x33},
174 {10, -1, "4294967295\0--------------------------------------------------------", 0x44},
175 {10, 0, "0\0-----------------------------------------------------------------", 0x77},
176 {10, 1, "1\0-----------------------------------------------------------------", 0x77},
177 {10, 12, "12\0----------------------------------------------------------------", 0x77},
178 {10, 123, "123\0---------------------------------------------------------------", 0x77},
179 {10, 1234, "1234\0--------------------------------------------------------------", 0x77},
180 {10, 12345, "12345\0-------------------------------------------------------------", 0x77},
181 {10, 123456, "123456\0------------------------------------------------------------", 0x77},
182 {10, 1234567, "1234567\0-----------------------------------------------------------", 0x77},
183 {10, 12345678, "12345678\0----------------------------------------------------------", 0x77},
184 {10, 123456789, "123456789\0---------------------------------------------------------", 0x77},
185 {10, 2147483646, "2147483646\0--------------------------------------------------------", 0x77},
186 {10, 2147483647, "2147483647\0--------------------------------------------------------", 0x77},
187 {10, 2147483648U, "-2147483648\0-------------------------------------------------------", 0x33},
188 {10, 2147483648U, "2147483648\0--------------------------------------------------------", 0x44},
189 {10, 2147483649U, "-2147483647\0-------------------------------------------------------", 0x33},
190 {10, 2147483649U, "2147483649\0--------------------------------------------------------", 0x44},
191 {10, 4294967294U, "-2\0----------------------------------------------------------------", 0x33},
192 {10, 4294967294U, "4294967294\0--------------------------------------------------------", 0x44},
193 {10, 4294967295U, "-1\0----------------------------------------------------------------", 0x33},
194 {10, 4294967295U, "4294967295\0--------------------------------------------------------", 0x44},
195
196 {16, 0, "0\0-----------------------------------------------------------------", 0x77},
197 {16, 1, "1\0-----------------------------------------------------------------", 0x77},
198 {16, 2147483646, "7ffffffe\0----------------------------------------------------------", 0x77},
199 {16, 2147483647, "7fffffff\0----------------------------------------------------------", 0x77},
200 {16, 0x80000000, "80000000\0----------------------------------------------------------", 0x77},
201 {16, 0x80000001, "80000001\0----------------------------------------------------------", 0x77},
202 {16, 0xFFFFFFFE, "fffffffe\0----------------------------------------------------------", 0x77},
203 {16, 0xFFFFFFFF, "ffffffff\0----------------------------------------------------------", 0x77},
204
205 { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x77},
206 { 2, 65536, "10000000000000000\0-------------------------------------------------", 0x77},
207 { 2, 131072, "100000000000000000\0------------------------------------------------", 0x77},
208 {16, 0xffffffff, "ffffffff\0----------------------------------------------------------", 0x77},
209 {16, 0xa, "a\0-----------------------------------------------------------------", 0x77},
210 {16, 0, "0\0-----------------------------------------------------------------", 0x77},
211 {20, 3368421, "111111\0------------------------------------------------------------", 0x77},
212 {36, 62193781, "111111\0------------------------------------------------------------", 0x77},
213 {37, 71270178, "111111\0------------------------------------------------------------", 0x77},
214};
215#define NB_ULONG2STR (sizeof(ulong2str)/sizeof(*ulong2str))
216
217
218static void one_itoa_test(int test_num, const ulong2str_t *ulong2str)
219{
220 char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
221 int value;
223
224 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
225 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
227 result = p_itoa(value, dest_str, ulong2str->base);
228 ok(result == dest_str,
229 "(test %d): _itoa(%d, [out], %d) has result %p, expected: %p\n",
230 test_num, value, ulong2str->base, result, dest_str);
232 "(test %d): _itoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
233 test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
234}
235
236
237static void one_ltoa_test(int test_num, const ulong2str_t *ulong2str)
238{
239 char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
240 LONG value;
242
243 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
244 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
246 result = p_ltoa(ulong2str->value, dest_str, ulong2str->base);
247 ok(result == dest_str,
248 "(test %d): _ltoa(%d, [out], %d) has result %p, expected: %p\n",
249 test_num, value, ulong2str->base, result, dest_str);
251 "(test %d): _ltoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
252 test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
253}
254
255
256static void one_ultoa_test(int test_num, const ulong2str_t *ulong2str)
257{
258 char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
259 ULONG value;
261
262 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
263 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
265 result = p_ultoa(ulong2str->value, dest_str, ulong2str->base);
266 ok(result == dest_str,
267 "(test %d): _ultoa(%u, [out], %d) has result %p, expected: %p\n",
268 test_num, value, ulong2str->base, result, dest_str);
270 "(test %d): _ultoa(%u, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
271 test_num, value, ulong2str->base, dest_str, ulong2str->Buffer);
272}
273
274
275static void test_ulongtoa(void)
276{
277 int test_num;
278
279 for (test_num = 0; test_num < NB_ULONG2STR; test_num++) {
280 if (ulong2str[test_num].mask & 0x01) {
281 one_itoa_test(test_num, &ulong2str[test_num]);
282 } /* if */
283 if (ulong2str[test_num].mask & 0x02) {
284 one_ltoa_test(test_num, &ulong2str[test_num]);
285 } /* if */
286 if (ulong2str[test_num].mask & 0x04) {
287 one_ultoa_test(test_num, &ulong2str[test_num]);
288 } /* if */
289 } /* for */
290}
291
292
293static void one_itow_test(int test_num, const ulong2str_t *ulong2str)
294{
295 int pos;
296 WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
297 WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
298 UNICODE_STRING unicode_string;
299 STRING ansi_str;
300 int value;
302
303 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
304 expected_wstr[pos] = ulong2str->Buffer[pos];
305 } /* for */
306 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
307
308 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
309 dest_wstr[pos] = '-';
310 } /* for */
311 dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
312 unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
313 unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
314 unicode_string.Buffer = dest_wstr;
316 result = p_itow(value, dest_wstr, ulong2str->base);
317 pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
318 ok(result == dest_wstr,
319 "(test %d): _itow(%d, [out], %d) has result %p, expected: %p\n",
320 test_num, value, ulong2str->base, result, dest_wstr);
321 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
322 "(test %d): _itow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
323 test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
324 pRtlFreeAnsiString(&ansi_str);
325}
326
327
328static void one_ltow_test(int test_num, const ulong2str_t *ulong2str)
329{
330 int pos;
331 WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
332 WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
333 UNICODE_STRING unicode_string;
334 STRING ansi_str;
335 LONG value;
337
338 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
339 expected_wstr[pos] = ulong2str->Buffer[pos];
340 } /* for */
341 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
342
343 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
344 dest_wstr[pos] = '-';
345 } /* for */
346 dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
347 unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
348 unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
349 unicode_string.Buffer = dest_wstr;
350
352 result = p_ltow(value, dest_wstr, ulong2str->base);
353 pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
354 ok(result == dest_wstr,
355 "(test %d): _ltow(%d, [out], %d) has result %p, expected: %p\n",
356 test_num, value, ulong2str->base, result, dest_wstr);
357 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
358 "(test %d): _ltow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
359 test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
360 pRtlFreeAnsiString(&ansi_str);
361}
362
363
364static void one_ultow_test(int test_num, const ulong2str_t *ulong2str)
365{
366 int pos;
367 WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
368 WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
369 UNICODE_STRING unicode_string;
370 STRING ansi_str;
371 ULONG value;
373
374 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
375 expected_wstr[pos] = ulong2str->Buffer[pos];
376 } /* for */
377 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
378
379 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
380 dest_wstr[pos] = '-';
381 } /* for */
382 dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
383 unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
384 unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
385 unicode_string.Buffer = dest_wstr;
386
388 result = p_ultow(value, dest_wstr, ulong2str->base);
389 pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
390 ok(result == dest_wstr,
391 "(test %d): _ultow(%u, [out], %d) has result %p, expected: %p\n",
392 test_num, value, ulong2str->base, result, dest_wstr);
393 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
394 "(test %d): _ultow(%u, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
395 test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer);
396 pRtlFreeAnsiString(&ansi_str);
397}
398
399
400static void test_ulongtow(void)
401{
402 int test_num;
404
405 for (test_num = 0; test_num < NB_ULONG2STR; test_num++) {
406 if (ulong2str[test_num].mask & 0x10) {
407 one_itow_test(test_num, &ulong2str[test_num]);
408 } /* if */
409 if (ulong2str[test_num].mask & 0x20) {
410 one_ltow_test(test_num, &ulong2str[test_num]);
411 } /* if */
412 if (ulong2str[test_num].mask & 0x40) {
413 one_ultow_test(test_num, &ulong2str[test_num]);
414 } /* if */
415 } /* for */
416
417 if (0) {
418 /* Crashes on XP and W2K3 */
419 result = p_itow(ulong2str[0].value, NULL, 10);
420 ok(result == NULL,
421 "(test a): _itow(%d, NULL, 10) has result %p, expected: NULL\n",
423 }
424
425 if (0) {
426 /* Crashes on XP and W2K3 */
427 result = p_ltow(ulong2str[0].value, NULL, 10);
428 ok(result == NULL,
429 "(test b): _ltow(%d, NULL, 10) has result %p, expected: NULL\n",
431 }
432
433 if (0) {
434 /* Crashes on XP and W2K3 */
435 result = p_ultow(ulong2str[0].value, NULL, 10);
436 ok(result == NULL,
437 "(test c): _ultow(%d, NULL, 10) has result %p, expected: NULL\n",
439 }
440}
441
442#define ULL(a,b) (((ULONGLONG)(a) << 32) | (b))
443
444typedef struct {
445 int base;
447 const char *Buffer;
448 int mask; /* ntdll/msvcrt: 0x01=i64toa, 0x02=ui64toa, 0x04=wrong _i64toa try next example */
449 /* 0x10=i64tow, 0x20=ui64tow, 0x40=wrong _i64tow try next example */
451
453 {10, 123, "123\0---------------------------------------------------------------", 0x33},
454
455 { 2, 0x80000000U, "10000000000000000000000000000000\0----------------------------------", 0x33},
456 { 2, -2147483647, "1111111111111111111111111111111110000000000000000000000000000001\0--", 0x33},
457 { 2, -65537, "1111111111111111111111111111111111111111111111101111111111111111\0--", 0x33},
458 { 2, -65536, "1111111111111111111111111111111111111111111111110000000000000000\0--", 0x33},
459 { 2, -65535, "1111111111111111111111111111111111111111111111110000000000000001\0--", 0x33},
460 { 2, -32768, "1111111111111111111111111111111111111111111111111000000000000000\0--", 0x33},
461 { 2, -32767, "1111111111111111111111111111111111111111111111111000000000000001\0--", 0x33},
462 { 2, -2, "1111111111111111111111111111111111111111111111111111111111111110\0--", 0x33},
463 { 2, -1, "1111111111111111111111111111111111111111111111111111111111111111\0--", 0x33},
464 { 2, 0, "0\0-----------------------------------------------------------------", 0x33},
465 { 2, 1, "1\0-----------------------------------------------------------------", 0x33},
466 { 2, 10, "1010\0--------------------------------------------------------------", 0x33},
467 { 2, 100, "1100100\0-----------------------------------------------------------", 0x33},
468 { 2, 1000, "1111101000\0--------------------------------------------------------", 0x33},
469 { 2, 10000, "10011100010000\0----------------------------------------------------", 0x33},
470 { 2, 32767, "111111111111111\0---------------------------------------------------", 0x33},
471 { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x33},
472 { 2, 65535, "1111111111111111\0--------------------------------------------------", 0x33},
473 { 2, 100000, "11000011010100000\0-------------------------------------------------", 0x33},
474 { 2, 234567, "111001010001000111\0------------------------------------------------", 0x33},
475 { 2, 300000, "1001001001111100000\0-----------------------------------------------", 0x33},
476 { 2, 524287, "1111111111111111111\0-----------------------------------------------", 0x33},
477 { 2, 524288, "10000000000000000000\0----------------------------------------------", 0x33},
478 { 2, 1000000, "11110100001001000000\0----------------------------------------------", 0x33},
479 { 2, 10000000, "100110001001011010000000\0------------------------------------------", 0x33},
480 { 2, 100000000, "101111101011110000100000000\0---------------------------------------", 0x33},
481 { 2, 1000000000, "111011100110101100101000000000\0------------------------------------", 0x33},
482 { 2, 1073741823, "111111111111111111111111111111\0------------------------------------", 0x33},
483 { 2, 2147483646, "1111111111111111111111111111110\0-----------------------------------", 0x33},
484 { 2, 2147483647, "1111111111111111111111111111111\0-----------------------------------", 0x33},
485 { 2, 2147483648U, "10000000000000000000000000000000\0----------------------------------", 0x33},
486 { 2, 2147483649U, "10000000000000000000000000000001\0----------------------------------", 0x33},
487 { 2, 4294967294U, "11111111111111111111111111111110\0----------------------------------", 0x33},
488 { 2, 0xFFFFFFFF, "11111111111111111111111111111111\0----------------------------------", 0x33},
489 { 2, ULL(0x1,0xffffffff), "111111111111111111111111111111111\0---------------------------------", 0x33},
490 { 2, ((ULONGLONG)100000)*100000, "1001010100000010111110010000000000\0--------------------------------", 0x33},
491 { 2, ULL(0x3,0xffffffff), "1111111111111111111111111111111111\0--------------------------------", 0x33},
492 { 2, ULL(0x7,0xffffffff), "11111111111111111111111111111111111\0-------------------------------", 0x33},
493 { 2, ULL(0xf,0xffffffff), "111111111111111111111111111111111111\0------------------------------", 0x33},
494 { 2, ((ULONGLONG)100000)*1000000, "1011101001000011101101110100000000000\0-----------------------------", 0x33},
495 { 2, ULL(0x1f,0xffffffff), "1111111111111111111111111111111111111\0-----------------------------", 0x33},
496 { 2, ULL(0x3f,0xffffffff), "11111111111111111111111111111111111111\0----------------------------", 0x33},
497 { 2, ULL(0x7f,0xffffffff), "111111111111111111111111111111111111111\0---------------------------", 0x33},
498 { 2, ULL(0xff,0xffffffff), "1111111111111111111111111111111111111111\0--------------------------", 0x33},
499
500 { 8, 0x80000000U, "20000000000\0-------------------------------------------------------", 0x33},
501 { 8, -2147483647, "1777777777760000000001\0--------------------------------------------", 0x33},
502 { 8, -2, "1777777777777777777776\0--------------------------------------------", 0x33},
503 { 8, -1, "1777777777777777777777\0--------------------------------------------", 0x33},
504 { 8, 0, "0\0-----------------------------------------------------------------", 0x33},
505 { 8, 1, "1\0-----------------------------------------------------------------", 0x33},
506 { 8, 2147483646, "17777777776\0-------------------------------------------------------", 0x33},
507 { 8, 2147483647, "17777777777\0-------------------------------------------------------", 0x33},
508 { 8, 2147483648U, "20000000000\0-------------------------------------------------------", 0x33},
509 { 8, 2147483649U, "20000000001\0-------------------------------------------------------", 0x33},
510 { 8, 4294967294U, "37777777776\0-------------------------------------------------------", 0x33},
511 { 8, 4294967295U, "37777777777\0-------------------------------------------------------", 0x33},
512
513 {10, 0x80000000U, "2147483648\0--------------------------------------------------------", 0x33},
514 {10, -2147483647, "-2147483647\0-------------------------------------------------------", 0x55},
515 {10, -2147483647, "-18446744071562067969\0---------------------------------------------", 0x00},
516 {10, -2147483647, "18446744071562067969\0----------------------------------------------", 0x22},
517 {10, -2, "-2\0----------------------------------------------------------------", 0x55},
518 {10, -2, "-18446744073709551614\0---------------------------------------------", 0x00},
519 {10, -2, "18446744073709551614\0----------------------------------------------", 0x22},
520 {10, -1, "-1\0----------------------------------------------------------------", 0x55},
521 {10, -1, "-18446744073709551615\0---------------------------------------------", 0x00},
522 {10, -1, "18446744073709551615\0----------------------------------------------", 0x22},
523 {10, 0, "0\0-----------------------------------------------------------------", 0x33},
524 {10, 1, "1\0-----------------------------------------------------------------", 0x33},
525 {10, 12, "12\0----------------------------------------------------------------", 0x33},
526 {10, 123, "123\0---------------------------------------------------------------", 0x33},
527 {10, 1234, "1234\0--------------------------------------------------------------", 0x33},
528 {10, 12345, "12345\0-------------------------------------------------------------", 0x33},
529 {10, 123456, "123456\0------------------------------------------------------------", 0x33},
530 {10, 1234567, "1234567\0-----------------------------------------------------------", 0x33},
531 {10, 12345678, "12345678\0----------------------------------------------------------", 0x33},
532 {10, 123456789, "123456789\0---------------------------------------------------------", 0x33},
533 {10, 2147483646, "2147483646\0--------------------------------------------------------", 0x33},
534 {10, 2147483647, "2147483647\0--------------------------------------------------------", 0x33},
535 {10, 2147483648U, "2147483648\0--------------------------------------------------------", 0x33},
536 {10, 2147483649U, "2147483649\0--------------------------------------------------------", 0x33},
537 {10, 4294967294U, "4294967294\0--------------------------------------------------------", 0x33},
538 {10, 4294967295U, "4294967295\0--------------------------------------------------------", 0x33},
539 {10, ULL(0x2,0xdfdc1c35), "12345678901\0-------------------------------------------------------", 0x33},
540 {10, ULL(0xe5,0xf4c8f374), "987654321012\0------------------------------------------------------", 0x33},
541 {10, ULL(0x1c0,0xfc161e3e), "1928374656574\0-----------------------------------------------------", 0x33},
542 {10, ULL(0xbad,0xcafeface), "12841062955726\0----------------------------------------------------", 0x33},
543 {10, ULL(0x5bad,0xcafeface), "100801993177806\0---------------------------------------------------", 0x33},
544 {10, ULL(0xaface,0xbeefcafe), "3090515640699646\0--------------------------------------------------", 0x33},
545 {10, ULL(0xa5beef,0xabcdcafe), "46653307746110206\0-------------------------------------------------", 0x33},
546 {10, ULL(0x1f8cf9b,0xf2df3af1), "142091656963767025\0------------------------------------------------", 0x33},
547 {10, ULL(0x0fffffff,0xffffffff), "1152921504606846975\0-----------------------------------------------", 0x33},
548 {10, ULL(0x7fffffff,0xffffffff), "9223372036854775807\0-----------------------------------------------", 0x33},
549 {10, ULL(0x80000000,0x00000000), "-9223372036854775808\0----------------------------------------------", 0x11},
550 {10, ULL(0x80000000,0x00000000), "9223372036854775808\0-----------------------------------------------", 0x22},
551 {10, ULL(0x80000000,0x00000001), "-9223372036854775807\0----------------------------------------------", 0x55},
552 {10, ULL(0x80000000,0x00000001), "-9223372036854775809\0----------------------------------------------", 0x00},
553 {10, ULL(0x80000000,0x00000001), "9223372036854775809\0-----------------------------------------------", 0x22},
554 {10, ULL(0x80000000,0x00000002), "-9223372036854775806\0----------------------------------------------", 0x55},
555 {10, ULL(0x80000000,0x00000002), "-9223372036854775810\0----------------------------------------------", 0x00},
556 {10, ULL(0x80000000,0x00000002), "9223372036854775810\0-----------------------------------------------", 0x22},
557 {10, ULL(0xffffffff,0xfffffffe), "-2\0----------------------------------------------------------------", 0x55},
558 {10, ULL(0xffffffff,0xfffffffe), "-18446744073709551614\0---------------------------------------------", 0x00},
559 {10, ULL(0xffffffff,0xfffffffe), "18446744073709551614\0----------------------------------------------", 0x22},
560 {10, ULL(0xffffffff,0xffffffff), "-1\0----------------------------------------------------------------", 0x55},
561 {10, ULL(0xffffffff,0xffffffff), "-18446744073709551615\0---------------------------------------------", 0x00},
562 {10, ULL(0xffffffff,0xffffffff), "18446744073709551615\0----------------------------------------------", 0x22},
563
564 {16, 0, "0\0-----------------------------------------------------------------", 0x33},
565 {16, 1, "1\0-----------------------------------------------------------------", 0x33},
566 {16, 2147483646, "7ffffffe\0----------------------------------------------------------", 0x33},
567 {16, 2147483647, "7fffffff\0----------------------------------------------------------", 0x33},
568 {16, 0x80000000, "80000000\0----------------------------------------------------------", 0x33},
569 {16, 0x80000001, "80000001\0----------------------------------------------------------", 0x33},
570 {16, 0xFFFFFFFE, "fffffffe\0----------------------------------------------------------", 0x33},
571 {16, 0xFFFFFFFF, "ffffffff\0----------------------------------------------------------", 0x33},
572 {16, ULL(0x1,0x00000000), "100000000\0---------------------------------------------------------", 0x33},
573 {16, ULL(0xbad,0xdeadbeef), "baddeadbeef\0-------------------------------------------------------", 0x33},
574 {16, ULL(0x80000000,0x00000000), "8000000000000000\0--------------------------------------------------", 0x33},
575 {16, ULL(0xfedcba98,0x76543210), "fedcba9876543210\0--------------------------------------------------", 0x33},
576 {16, ULL(0xffffffff,0x80000001), "ffffffff80000001\0--------------------------------------------------", 0x33},
577 {16, ULL(0xffffffff,0xfffffffe), "fffffffffffffffe\0--------------------------------------------------", 0x33},
578 {16, ULL(0xffffffff,0xffffffff), "ffffffffffffffff\0--------------------------------------------------", 0x33},
579
580 { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x33},
581 { 2, 65536, "10000000000000000\0-------------------------------------------------", 0x33},
582 { 2, 131072, "100000000000000000\0------------------------------------------------", 0x33},
583 {16, 0xffffffff, "ffffffff\0----------------------------------------------------------", 0x33},
584 {16, 0xa, "a\0-----------------------------------------------------------------", 0x33},
585 {16, 0, "0\0-----------------------------------------------------------------", 0x33},
586 {20, 3368421, "111111\0------------------------------------------------------------", 0x33},
587 {36, 62193781, "111111\0------------------------------------------------------------", 0x33},
588 {37, 71270178, "111111\0------------------------------------------------------------", 0x33},
589 {99, ULL(0x2,0x3c9e468c), "111111\0------------------------------------------------------------", 0x33},
590};
591#define NB_ULONGLONG2STR (sizeof(ulonglong2str)/sizeof(*ulonglong2str))
592
593
594static void one_i64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
595{
597 char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
598
599 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
600 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
601 result = p_i64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
602 ok(result == dest_str,
603 "(test %d): _i64toa(%s, [out], %d) has result %p, expected: %p\n",
605 if (ulonglong2str->mask & 0x04) {
606 if (memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
607 if (memcmp(dest_str, ulonglong2str[1].Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) {
609 "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
612 } /* if */
613 } /* if */
614 } else {
616 "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
619 } /* if */
620}
621
622
623static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
624{
626 char dest_str[LARGE_STRI_BUFFER_LENGTH + 1];
627
628 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
629 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
630 result = p_ui64toa(ulonglong2str->value, dest_str, ulonglong2str->base);
631 ok(result == dest_str,
632 "(test %d): _ui64toa(%s, [out], %d) has result %p, expected: %p\n",
635 "(test %d): _ui64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
638}
639
640
641static void test_ulonglongtoa(void)
642{
643 int test_num;
644
645 for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) {
646 if (ulonglong2str[test_num].mask & 0x01) {
647 one_i64toa_test(test_num, &ulonglong2str[test_num]);
648 } /* if */
649 if (p_ui64toa != NULL) {
650 if (ulonglong2str[test_num].mask & 0x02) {
651 one_ui64toa_test(test_num, &ulonglong2str[test_num]);
652 } /* if */
653 } /* if */
654 } /* for */
655}
656
657
658static void one_i64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
659{
660 int pos;
661 WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
662 WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
663 UNICODE_STRING unicode_string;
664 STRING ansi_str;
666
667 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
668 expected_wstr[pos] = ulonglong2str->Buffer[pos];
669 } /* for */
670 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
671
672 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
673 dest_wstr[pos] = '-';
674 } /* for */
675 dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
676 unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
677 unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
678 unicode_string.Buffer = dest_wstr;
679
680 result = p_i64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
681 pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
682 ok(result == dest_wstr,
683 "(test %d): _i64tow(0x%s, [out], %d) has result %p, expected: %p\n",
685 if (ulonglong2str->mask & 0x04) {
686 if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
687 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
688 expected_wstr[pos] = ulonglong2str[1].Buffer[pos];
689 } /* for */
690 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
691 if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) {
692 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
693 "(test %d): _i64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
695 ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
696 } /* if */
697 } /* if */
698 } else {
699 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
700 "(test %d): _i64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
702 ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
703 } /* if */
704 pRtlFreeAnsiString(&ansi_str);
705}
706
707
708static void one_ui64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
709{
710 int pos;
711 WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
712 WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1];
713 UNICODE_STRING unicode_string;
714 STRING ansi_str;
716
717 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
718 expected_wstr[pos] = ulonglong2str->Buffer[pos];
719 } /* for */
720 expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
721
722 for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) {
723 dest_wstr[pos] = '-';
724 } /* for */
725 dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0';
726 unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR);
727 unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR);
728 unicode_string.Buffer = dest_wstr;
729
730 result = p_ui64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base);
731 pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
732 ok(result == dest_wstr,
733 "(test %d): _ui64tow(0x%s, [out], %d) has result %p, expected: %p\n",
735 ulonglong2str->base, result, dest_wstr);
736 ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
737 "(test %d): _ui64tow(0x%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
739 ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer);
740 pRtlFreeAnsiString(&ansi_str);
741}
742
743
744static void test_ulonglongtow(void)
745{
746 int test_num;
748
749 for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) {
750 if (ulonglong2str[test_num].mask & 0x10) {
751 one_i64tow_test(test_num, &ulonglong2str[test_num]);
752 } /* if */
753 if (p_ui64tow) {
754 if (ulonglong2str[test_num].mask & 0x20) {
755 one_ui64tow_test(test_num, &ulonglong2str[test_num]);
756 } /* if */
757 } /* if */
758 } /* for */
759
760 if (0) {
761 /* Crashes on XP and W2K3 */
762 result = p_i64tow(ulonglong2str[0].value, NULL, 10);
763 ok(result == NULL,
764 "(test d): _i64tow(0x%s, NULL, 10) has result %p, expected: NULL\n",
766 }
767
768 if (p_ui64tow) {
769 if (0) {
770 /* Crashes on XP and W2K3 */
771 result = p_ui64tow(ulonglong2str[0].value, NULL, 10);
772 ok(result == NULL,
773 "(test e): _ui64tow(0x%s, NULL, 10) has result %p, expected: NULL\n",
775 }
776 } /* if */
777}
778
779
780typedef struct {
781 const char *str;
783} str2long_t;
784
785static const str2long_t str2long[] = {
786 { "1011101100", 1011101100 },
787 { "1234567", 1234567 },
788 { "-214", -214 },
789 { "+214", 214 }, /* The + sign is allowed also */
790 { "--214", 0 }, /* Do not accept more than one sign */
791 { "-+214", 0 },
792 { "++214", 0 },
793 { "+-214", 0 },
794 { "\00141", 0 }, /* not whitespace char 1 */
795 { "\00242", 0 }, /* not whitespace char 2 */
796 { "\00343", 0 }, /* not whitespace char 3 */
797 { "\00444", 0 }, /* not whitespace char 4 */
798 { "\00545", 0 }, /* not whitespace char 5 */
799 { "\00646", 0 }, /* not whitespace char 6 */
800 { "\00747", 0 }, /* not whitespace char 7 */
801 { "\01050", 0 }, /* not whitespace char 8 */
802 { "\01151", 51 }, /* is whitespace char 9 (tab) */
803 { "\01252", 52 }, /* is whitespace char 10 (lf) */
804 { "\01353", 53 }, /* is whitespace char 11 (vt) */
805 { "\01454", 54 }, /* is whitespace char 12 (ff) */
806 { "\01555", 55 }, /* is whitespace char 13 (cr) */
807 { "\01656", 0 }, /* not whitespace char 14 */
808 { "\01757", 0 }, /* not whitespace char 15 */
809 { "\02060", 0 }, /* not whitespace char 16 */
810 { "\02161", 0 }, /* not whitespace char 17 */
811 { "\02262", 0 }, /* not whitespace char 18 */
812 { "\02363", 0 }, /* not whitespace char 19 */
813 { "\02464", 0 }, /* not whitespace char 20 */
814 { "\02565", 0 }, /* not whitespace char 21 */
815 { "\02666", 0 }, /* not whitespace char 22 */
816 { "\02767", 0 }, /* not whitespace char 23 */
817 { "\03070", 0 }, /* not whitespace char 24 */
818 { "\03171", 0 }, /* not whitespace char 25 */
819 { "\03272", 0 }, /* not whitespace char 26 */
820 { "\03373", 0 }, /* not whitespace char 27 */
821 { "\03474", 0 }, /* not whitespace char 28 */
822 { "\03575", 0 }, /* not whitespace char 29 */
823 { "\03676", 0 }, /* not whitespace char 30 */
824 { "\03777", 0 }, /* not whitespace char 31 */
825 { "\04080", 80 }, /* is whitespace char 32 (space) */
826 { " \n \r \t214", 214 },
827 { " \n \r \t+214", 214 }, /* Signs can be used after whitespace */
828 { " \n \r \t-214", -214 },
829 { "+214 0", 214 }, /* Space terminates the number */
830 { " 214.01", 214 }, /* Decimal point not accepted */
831 { " 214,01", 214 }, /* Decimal comma not accepted */
832 { "f81", 0 },
833 { "0x12345", 0 }, /* Hex not accepted */
834 { "00x12345", 0 },
835 { "0xx12345", 0 },
836 { "1x34", 1 },
837 { "-9999999999", -1410065407 }, /* Big negative integer */
838 { "-2147483649", 2147483647 }, /* Too small to fit in 32 Bits */
839 { "-2147483648", 0x80000000 }, /* Smallest negative integer */
840 { "-2147483647", -2147483647 },
841 { "-1", -1 },
842 { "0", 0 },
843 { "1", 1 },
844 { "2147483646", 2147483646 },
845 { "2147483647", 2147483647 }, /* Largest signed positive integer */
846 { "2147483648", 2147483648UL }, /* Positive int equal to smallest negative int */
847 { "2147483649", 2147483649UL },
848 { "4294967294", 4294967294UL },
849 { "4294967295", 4294967295UL }, /* Largest unsigned integer */
850 { "4294967296", 0 }, /* Too big to fit in 32 Bits */
851 { "9999999999", 1410065407 }, /* Big positive integer */
852 { "056789", 56789 }, /* Leading zero and still decimal */
853 { "b1011101100", 0 }, /* Binary (b-notation) */
854 { "-b1011101100", 0 }, /* Negative Binary (b-notation) */
855 { "b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */
856 { "0b1011101100", 0 }, /* Binary (0b-notation) */
857 { "-0b1011101100", 0 }, /* Negative binary (0b-notation) */
858 { "0b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */
859 { "-0b10123456789", 0 }, /* Negative binary with nonbinary digits (2-9) */
860 { "0b1", 0 }, /* one digit binary */
861 { "0b2", 0 }, /* empty binary */
862 { "0b", 0 }, /* empty binary */
863 { "o1234567", 0 }, /* Octal (o-notation) */
864 { "-o1234567", 0 }, /* Negative Octal (o-notation) */
865 { "o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */
866 { "0o1234567", 0 }, /* Octal (0o-notation) */
867 { "-0o1234567", 0 }, /* Negative octal (0o-notation) */
868 { "0o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */
869 { "-0o56789", 0 }, /* Negative octal with nonoctal digits (8 and 9) */
870 { "0o7", 0 }, /* one digit octal */
871 { "0o8", 0 }, /* empty octal */
872 { "0o", 0 }, /* empty octal */
873 { "0d1011101100", 0 }, /* explicit decimal with 0d */
874 { "x89abcdef", 0 }, /* Hex with lower case digits a-f (x-notation) */
875 { "xFEDCBA00", 0 }, /* Hex with upper case digits A-F (x-notation) */
876 { "-xFEDCBA00", 0 }, /* Negative Hexadecimal (x-notation) */
877 { "0x89abcdef", 0 }, /* Hex with lower case digits a-f (0x-notation) */
878 { "0xFEDCBA00", 0 }, /* Hex with upper case digits A-F (0x-notation) */
879 { "-0xFEDCBA00", 0 }, /* Negative Hexadecimal (0x-notation) */
880 { "0xabcdefgh", 0 }, /* Hex with illegal lower case digits (g-z) */
881 { "0xABCDEFGH", 0 }, /* Hex with illegal upper case digits (G-Z) */
882 { "0xF", 0 }, /* one digit hexadecimal */
883 { "0xG", 0 }, /* empty hexadecimal */
884 { "0x", 0 }, /* empty hexadecimal */
885 { "", 0 }, /* empty string */
886/* { NULL, 0 }, */ /* NULL as string */
887};
888#define NB_STR2LONG (sizeof(str2long)/sizeof(*str2long))
889
890
891static void test_wtoi(void)
892{
893 int test_num;
894 UNICODE_STRING uni;
895 int result;
896
897 for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
898 pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
899 result = p_wtoi(uni.Buffer);
900 ok(result == str2long[test_num].value,
901 "(test %d): call failed: _wtoi(\"%s\") has result %d, expected: %d\n",
902 test_num, str2long[test_num].str, result, str2long[test_num].value);
903 pRtlFreeUnicodeString(&uni);
904 } /* for */
905}
906
907static void test_atoi(void)
908{
909 int test_num;
910 int result;
911
912 for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
913 result = patoi(str2long[test_num].str);
914 ok(result == str2long[test_num].value,
915 "(test %d): call failed: _atoi(\"%s\") has result %d, expected: %d\n",
916 test_num, str2long[test_num].str, result, str2long[test_num].value);
917 }
918}
919
920static void test_atol(void)
921{
922 int test_num;
923 int result;
924
925 for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
926 result = patol(str2long[test_num].str);
927 ok(result == str2long[test_num].value,
928 "(test %d): call failed: _atol(\"%s\") has result %d, expected: %d\n",
929 test_num, str2long[test_num].str, result, str2long[test_num].value);
930 }
931}
932
933static void test_wtol(void)
934{
935 int test_num;
936 UNICODE_STRING uni;
937 LONG result;
938
939 for (test_num = 0; test_num < NB_STR2LONG; test_num++) {
940 pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str);
941 result = p_wtol(uni.Buffer);
942 ok(result == str2long[test_num].value,
943 "(test %d): call failed: _wtol(\"%s\") has result %d, expected: %d\n",
944 test_num, str2long[test_num].str, result, str2long[test_num].value);
945 pRtlFreeUnicodeString(&uni);
946 } /* for */
947}
948
949
950typedef struct {
951 const char *str;
955
956static const str2longlong_t str2longlong[] = {
957 { "1011101100", 1011101100 },
958 { "1234567", 1234567 },
959 { "-214", -214 },
960 { "+214", 214 }, /* The + sign is allowed also */
961 { "--214", 0 }, /* Do not accept more than one sign */
962 { "-+214", 0 },
963 { "++214", 0 },
964 { "+-214", 0 },
965 { "\00141", 0 }, /* not whitespace char 1 */
966 { "\00242", 0 }, /* not whitespace char 2 */
967 { "\00343", 0 }, /* not whitespace char 3 */
968 { "\00444", 0 }, /* not whitespace char 4 */
969 { "\00545", 0 }, /* not whitespace char 5 */
970 { "\00646", 0 }, /* not whitespace char 6 */
971 { "\00747", 0 }, /* not whitespace char 7 */
972 { "\01050", 0 }, /* not whitespace char 8 */
973 { "\01151", 51 }, /* is whitespace char 9 (tab) */
974 { "\01252", 52 }, /* is whitespace char 10 (lf) */
975 { "\01353", 53 }, /* is whitespace char 11 (vt) */
976 { "\01454", 54 }, /* is whitespace char 12 (ff) */
977 { "\01555", 55 }, /* is whitespace char 13 (cr) */
978 { "\01656", 0 }, /* not whitespace char 14 */
979 { "\01757", 0 }, /* not whitespace char 15 */
980 { "\02060", 0 }, /* not whitespace char 16 */
981 { "\02161", 0 }, /* not whitespace char 17 */
982 { "\02262", 0 }, /* not whitespace char 18 */
983 { "\02363", 0 }, /* not whitespace char 19 */
984 { "\02464", 0 }, /* not whitespace char 20 */
985 { "\02565", 0 }, /* not whitespace char 21 */
986 { "\02666", 0 }, /* not whitespace char 22 */
987 { "\02767", 0 }, /* not whitespace char 23 */
988 { "\03070", 0 }, /* not whitespace char 24 */
989 { "\03171", 0 }, /* not whitespace char 25 */
990 { "\03272", 0 }, /* not whitespace char 26 */
991 { "\03373", 0 }, /* not whitespace char 27 */
992 { "\03474", 0 }, /* not whitespace char 28 */
993 { "\03575", 0 }, /* not whitespace char 29 */
994 { "\03676", 0 }, /* not whitespace char 30 */
995 { "\03777", 0 }, /* not whitespace char 31 */
996 { "\04080", 80 }, /* is whitespace char 32 (space) */
997 { " \n \r \t214", 214 },
998 { " \n \r \t+214", 214 }, /* Signs can be used after whitespace */
999 { " \n \r \t-214", -214 },
1000 { "+214 0", 214 }, /* Space terminates the number */
1001 { " 214.01", 214 }, /* Decimal point not accepted */
1002 { " 214,01", 214 }, /* Decimal comma not accepted */
1003 { "f81", 0 },
1004 { "0x12345", 0 }, /* Hex not accepted */
1005 { "00x12345", 0 },
1006 { "0xx12345", 0 },
1007 { "1x34", 1 },
1008 { "-99999999999999999999", -ULL(0x6bc75e2d,0x630fffff), -1 }, /* Big negative integer */
1009 { "-9223372036854775809", ULL(0x7fffffff,0xffffffff), -1 }, /* Too small to fit in 64 bits */
1010 { "-9223372036854775808", ULL(0x80000000,0x00000000) }, /* Smallest negative 64 bit integer */
1011 { "-9223372036854775807", -ULL(0x7fffffff,0xffffffff) },
1012 { "-9999999999", -ULL(0x00000002,0x540be3ff) },
1013 { "-2147483649", -ULL(0x00000000,0x80000001) }, /* Too small to fit in 32 bits */
1014 { "-2147483648", -ULL(0x00000000,0x80000000) }, /* Smallest 32 bits negative integer */
1015 { "-2147483647", -2147483647 },
1016 { "-1", -1 },
1017 { "0", 0 },
1018 { "1", 1 },
1019 { "2147483646", 2147483646 },
1020 { "2147483647", 2147483647 }, /* Largest signed positive 32 bit integer */
1021 { "2147483648", ULL(0x00000000,0x80000000) }, /* Pos int equal to smallest neg 32 bit int */
1022 { "2147483649", ULL(0x00000000,0x80000001) },
1023 { "4294967294", ULL(0x00000000,0xfffffffe) },
1024 { "4294967295", ULL(0x00000000,0xffffffff) }, /* Largest unsigned 32 bit integer */
1025 { "4294967296", ULL(0x00000001,0x00000000) }, /* Too big to fit in 32 Bits */
1026 { "9999999999", ULL(0x00000002,0x540be3ff) },
1027 { "9223372036854775806", ULL(0x7fffffff,0xfffffffe) },
1028 { "9223372036854775807", ULL(0x7fffffff,0xffffffff) }, /* Largest signed positive 64 bit integer */
1029 { "9223372036854775808", ULL(0x80000000,0x00000000), 1 }, /* Pos int equal to smallest neg 64 bit int */
1030 { "9223372036854775809", ULL(0x80000000,0x00000001), 1 },
1031 { "18446744073709551614", ULL(0xffffffff,0xfffffffe), 1 },
1032 { "18446744073709551615", ULL(0xffffffff,0xffffffff), 1 }, /* Largest unsigned 64 bit integer */
1033 { "18446744073709551616", 0, 1 }, /* Too big to fit in 64 bits */
1034 { "99999999999999999999", ULL(0x6bc75e2d,0x630fffff), 1 }, /* Big positive integer */
1035 { "056789", 56789 }, /* Leading zero and still decimal */
1036 { "b1011101100", 0 }, /* Binary (b-notation) */
1037 { "-b1011101100", 0 }, /* Negative Binary (b-notation) */
1038 { "b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */
1039 { "0b1011101100", 0 }, /* Binary (0b-notation) */
1040 { "-0b1011101100", 0 }, /* Negative binary (0b-notation) */
1041 { "0b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */
1042 { "-0b10123456789", 0 }, /* Negative binary with nonbinary digits (2-9) */
1043 { "0b1", 0 }, /* one digit binary */
1044 { "0b2", 0 }, /* empty binary */
1045 { "0b", 0 }, /* empty binary */
1046 { "o1234567", 0 }, /* Octal (o-notation) */
1047 { "-o1234567", 0 }, /* Negative Octal (o-notation) */
1048 { "o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */
1049 { "0o1234567", 0 }, /* Octal (0o-notation) */
1050 { "-0o1234567", 0 }, /* Negative octal (0o-notation) */
1051 { "0o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */
1052 { "-0o56789", 0 }, /* Negative octal with nonoctal digits (8 and 9) */
1053 { "0o7", 0 }, /* one digit octal */
1054 { "0o8", 0 }, /* empty octal */
1055 { "0o", 0 }, /* empty octal */
1056 { "0d1011101100", 0 }, /* explicit decimal with 0d */
1057 { "x89abcdef", 0 }, /* Hex with lower case digits a-f (x-notation) */
1058 { "xFEDCBA00", 0 }, /* Hex with upper case digits A-F (x-notation) */
1059 { "-xFEDCBA00", 0 }, /* Negative Hexadecimal (x-notation) */
1060 { "0x89abcdef", 0 }, /* Hex with lower case digits a-f (0x-notation) */
1061 { "0xFEDCBA00", 0 }, /* Hex with upper case digits A-F (0x-notation) */
1062 { "-0xFEDCBA00", 0 }, /* Negative Hexadecimal (0x-notation) */
1063 { "0xabcdefgh", 0 }, /* Hex with illegal lower case digits (g-z) */
1064 { "0xABCDEFGH", 0 }, /* Hex with illegal upper case digits (G-Z) */
1065 { "0xF", 0 }, /* one digit hexadecimal */
1066 { "0xG", 0 }, /* empty hexadecimal */
1067 { "0x", 0 }, /* empty hexadecimal */
1068 { "", 0 }, /* empty string */
1069/* { NULL, 0 }, */ /* NULL as string */
1070};
1071#define NB_STR2LONGLONG (sizeof(str2longlong)/sizeof(*str2longlong))
1072
1073
1074static void test_atoi64(void)
1075{
1076 int test_num;
1078
1079 for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
1080 result = p_atoi64(str2longlong[test_num].str);
1081 if (str2longlong[test_num].overflow)
1082 ok(result == str2longlong[test_num].value ||
1083 (result == ((str2longlong[test_num].overflow == -1) ?
1084 ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff))),
1085 "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
1086 test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
1088 else
1089 ok(result == str2longlong[test_num].value,
1090 "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
1091 test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
1093 }
1094}
1095
1096
1097static void test_wtoi64(void)
1098{
1099 int test_num;
1100 UNICODE_STRING uni;
1102
1103 for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) {
1104 pRtlCreateUnicodeStringFromAsciiz(&uni, str2longlong[test_num].str);
1105 result = p_wtoi64(uni.Buffer);
1106 if (str2longlong[test_num].overflow)
1107 ok(result == str2longlong[test_num].value ||
1108 (result == ((str2longlong[test_num].overflow == -1) ?
1109 ULL(0x80000000,0x00000000) : ULL(0x7fffffff,0xffffffff))),
1110 "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
1111 test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
1113 else
1114 ok(result == str2longlong[test_num].value,
1115 "(test %d): call failed: _atoi64(\"%s\") has result 0x%s, expected: 0x%s\n",
1116 test_num, str2longlong[test_num].str, wine_dbgstr_longlong(result),
1118 pRtlFreeUnicodeString(&uni);
1119 }
1120}
1121
1122static void test_wcschr(void)
1123{
1124 static const WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
1125
1126 ok(p_wcschr(teststringW, 'a') == teststringW + 0,
1127 "wcschr should have returned a pointer to the first 'a' character\n");
1128 ok(p_wcschr(teststringW, 0) == teststringW + 11,
1129 "wcschr should have returned a pointer to the null terminator\n");
1130 ok(p_wcschr(teststringW, 'x') == NULL,
1131 "wcschr should have returned NULL\n");
1132}
1133
1134static void test_wcsrchr(void)
1135{
1136 static const WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
1137
1138 ok(p_wcsrchr(teststringW, 'a') == teststringW + 10,
1139 "wcsrchr should have returned a pointer to the last 'a' character\n");
1140 ok(p_wcsrchr(teststringW, 0) == teststringW + 11,
1141 "wcsrchr should have returned a pointer to the null terminator\n");
1142 ok(p_wcsrchr(teststringW, 'x') == NULL,
1143 "wcsrchr should have returned NULL\n");
1144}
1145
1146static void test_wcslwrupr(void)
1147{
1148 static WCHAR teststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
1149 static WCHAR emptyW[] = {0};
1150 static const WCHAR constemptyW[] = {0};
1151
1152 if (0) /* crashes on native */
1153 {
1154 static const WCHAR conststringW[] = {'a','b','r','a','c','a','d','a','b','r','a',0};
1155 ok(p_wcslwr((LPWSTR)conststringW) == conststringW, "p_wcslwr returned different string\n");
1156 ok(p_wcsupr((LPWSTR)conststringW) == conststringW, "p_wcsupr returned different string\n");
1157 ok(p_wcslwr(NULL) == NULL, "p_wcslwr didn't returned NULL\n");
1158 ok(p_wcsupr(NULL) == NULL, "p_wcsupr didn't returned NULL\n");
1159 }
1160 ok(p_wcslwr(teststringW) == teststringW, "p_wcslwr returned different string\n");
1161 ok(p_wcsupr(teststringW) == teststringW, "p_wcsupr returned different string\n");
1162 ok(p_wcslwr(emptyW) == emptyW, "p_wcslwr returned different string\n");
1163 ok(p_wcsupr(emptyW) == emptyW, "p_wcsupr returned different string\n");
1164 ok(p_wcslwr((LPWSTR)constemptyW) == constemptyW, "p_wcslwr returned different string\n");
1165 ok(p_wcsupr((LPWSTR)constemptyW) == constemptyW, "p_wcsupr returned different string\n");
1166}
1167
1168static int __cdecl intcomparefunc(const void *a, const void *b)
1169{
1170 const int *p = a, *q = b;
1171
1172 ok (a != b, "must never get the same pointer\n");
1173
1174 return *p - *q;
1175}
1176
1177static int __cdecl charcomparefunc(const void *a, const void *b)
1178{
1179 const char *p = a, *q = b;
1180
1181 ok (a != b, "must never get the same pointer\n");
1182
1183 return *p - *q;
1184}
1185
1186static int __cdecl strcomparefunc(const void *a, const void *b)
1187{
1188 const char * const *p = a;
1189 const char * const *q = b;
1190
1191 ok (a != b, "must never get the same pointer\n");
1192
1193 return lstrcmpA(*p, *q);
1194}
1195
1196static void test_qsort(void)
1197{
1198 int arr[5] = { 23, 42, 8, 4, 16 };
1199 char carr[5] = { 42, 23, 4, 8, 16 };
1200 const char *strarr[7] = {
1201 "Hello",
1202 "Wine",
1203 "World",
1204 "!",
1205 "Hopefully",
1206 "Sorted",
1207 "."
1208 };
1209
1210 p_qsort ((void*)arr, 0, sizeof(int), intcomparefunc);
1211 ok(arr[0] == 23, "badly sorted, nmemb=0, arr[0] is %d\n", arr[0]);
1212 ok(arr[1] == 42, "badly sorted, nmemb=0, arr[1] is %d\n", arr[1]);
1213 ok(arr[2] == 8, "badly sorted, nmemb=0, arr[2] is %d\n", arr[2]);
1214 ok(arr[3] == 4, "badly sorted, nmemb=0, arr[3] is %d\n", arr[3]);
1215 ok(arr[4] == 16, "badly sorted, nmemb=0, arr[4] is %d\n", arr[4]);
1216
1217 p_qsort ((void*)arr, 1, sizeof(int), intcomparefunc);
1218 ok(arr[0] == 23, "badly sorted, nmemb=1, arr[0] is %d\n", arr[0]);
1219 ok(arr[1] == 42, "badly sorted, nmemb=1, arr[1] is %d\n", arr[1]);
1220 ok(arr[2] == 8, "badly sorted, nmemb=1, arr[2] is %d\n", arr[2]);
1221 ok(arr[3] == 4, "badly sorted, nmemb=1, arr[3] is %d\n", arr[3]);
1222 ok(arr[4] == 16, "badly sorted, nmemb=1, arr[4] is %d\n", arr[4]);
1223
1224 p_qsort ((void*)arr, 5, 0, intcomparefunc);
1225 ok(arr[0] == 23, "badly sorted, size=0, arr[0] is %d\n", arr[0]);
1226 ok(arr[1] == 42, "badly sorted, size=0, arr[1] is %d\n", arr[1]);
1227 ok(arr[2] == 8, "badly sorted, size=0, arr[2] is %d\n", arr[2]);
1228 ok(arr[3] == 4, "badly sorted, size=0, arr[3] is %d\n", arr[3]);
1229 ok(arr[4] == 16, "badly sorted, size=0, arr[4] is %d\n", arr[4]);
1230
1231 p_qsort ((void*)arr, 5, sizeof(int), intcomparefunc);
1232 ok(arr[0] == 4, "badly sorted, arr[0] is %d\n", arr[0]);
1233 ok(arr[1] == 8, "badly sorted, arr[1] is %d\n", arr[1]);
1234 ok(arr[2] == 16, "badly sorted, arr[2] is %d\n", arr[2]);
1235 ok(arr[3] == 23, "badly sorted, arr[3] is %d\n", arr[3]);
1236 ok(arr[4] == 42, "badly sorted, arr[4] is %d\n", arr[4]);
1237
1238 p_qsort ((void*)carr, 5, sizeof(char), charcomparefunc);
1239 ok(carr[0] == 4, "badly sorted, carr[0] is %d\n", carr[0]);
1240 ok(carr[1] == 8, "badly sorted, carr[1] is %d\n", carr[1]);
1241 ok(carr[2] == 16, "badly sorted, carr[2] is %d\n", carr[2]);
1242 ok(carr[3] == 23, "badly sorted, carr[3] is %d\n", carr[3]);
1243 ok(carr[4] == 42, "badly sorted, carr[4] is %d\n", carr[4]);
1244
1245 p_qsort ((void*)strarr, 7, sizeof(char*), strcomparefunc);
1246 ok(!strcmp(strarr[0],"!"), "badly sorted, strarr[0] is %s\n", strarr[0]);
1247 ok(!strcmp(strarr[1],"."), "badly sorted, strarr[1] is %s\n", strarr[1]);
1248 ok(!strcmp(strarr[2],"Hello"), "badly sorted, strarr[2] is %s\n", strarr[2]);
1249 ok(!strcmp(strarr[3],"Hopefully"), "badly sorted, strarr[3] is %s\n", strarr[3]);
1250 ok(!strcmp(strarr[4],"Sorted"), "badly sorted, strarr[4] is %s\n", strarr[4]);
1251 ok(!strcmp(strarr[5],"Wine"), "badly sorted, strarr[5] is %s\n", strarr[5]);
1252 ok(!strcmp(strarr[6],"World"), "badly sorted, strarr[6] is %s\n", strarr[6]);
1253}
1254
1255static void test_bsearch(void)
1256{
1257 int arr[7] = { 1, 3, 4, 8, 16, 23, 42 };
1258 int *x, l, i, j;
1259
1260 /* just try all array sizes */
1261 for (j=1;j<sizeof(arr)/sizeof(arr[0]);j++) {
1262 for (i=0;i<j;i++) {
1263 l = arr[i];
1264 x = p_bsearch (&l, arr, j, sizeof(arr[0]), intcomparefunc);
1265 ok (x == &arr[i], "bsearch did not find %d entry in loopsize %d.\n", i, j);
1266 }
1267 l = 4242;
1268 x = p_bsearch (&l, arr, j, sizeof(arr[0]), intcomparefunc);
1269 ok (x == NULL, "bsearch did find 4242 entry in loopsize %d.\n", j);
1270 }
1271}
1272
1273static void test__snprintf(void)
1274{
1275 const char *origstring = "XXXXXXXXXXXX";
1276 const char *teststring = "hello world";
1277 char buffer[32];
1278 int res;
1279
1280 res = p__snprintf(NULL, 0, teststring);
1281 ok(res == lstrlenA(teststring) || broken(res == -1) /* <= w2k */,
1282 "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
1283
1284 if (res != -1)
1285 {
1286 res = p__snprintf(NULL, 1, teststring);
1287 ok(res == lstrlenA(teststring) /* WinXP */ || res < 0 /* Vista and greater */,
1288 "_snprintf returned %d, expected %d or < 0.\n", res, lstrlenA(teststring));
1289 }
1290 res = p__snprintf(buffer, strlen(teststring) - 1, teststring);
1291 ok(res < 0, "_snprintf returned %d, expected < 0.\n", res);
1292
1293 strcpy(buffer, origstring);
1294 res = p__snprintf(buffer, strlen(teststring), teststring);
1295 ok(res == lstrlenA(teststring), "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
1296 ok(!strcmp(buffer, "hello worldX"), "_snprintf returned buffer '%s', expected 'hello worldX'.\n", buffer);
1297
1298 strcpy(buffer, origstring);
1299 res = p__snprintf(buffer, strlen(teststring) + 1, teststring);
1300 ok(res == lstrlenA(teststring), "_snprintf returned %d, expected %d.\n", res, lstrlenA(teststring));
1301 ok(!strcmp(buffer, teststring), "_snprintf returned buffer '%s', expected '%s'.\n", buffer, teststring);
1302}
1303
1305{
1307
1308 if (p_ultoa)
1309 test_ulongtoa();
1310 if (p_ui64toa)
1312 if (p_atoi64)
1313 test_atoi64();
1314 if (p_ultow)
1315 test_ulongtow();
1316 if (p_ui64tow)
1318 if (p_wtoi)
1319 test_wtoi();
1320 if (p_wtol)
1321 test_wtol();
1322 if (p_wtoi64)
1323 test_wtoi64();
1324 if (p_wcschr)
1325 test_wcschr();
1326 if (p_wcsrchr)
1327 test_wcsrchr();
1328 if (p_wcslwr && p_wcsupr)
1330 if (patoi)
1331 test_atoi();
1332 if (patol)
1333 test_atol();
1334 if (p_qsort)
1335 test_qsort();
1336 if (p_bsearch)
1337 test_bsearch();
1338 if (p__snprintf)
1340}
#define broken(x)
Definition: _sntprintf.h:21
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define __cdecl
Definition: accygwin.h:79
#define VOID
Definition: acefi.h:82
#define ok(value,...)
Definition: atltest.h:57
#define START_TEST(x)
Definition: atltest.h:75
r l[0]
Definition: byte_order.h:167
Definition: bufpool.h:45
#define NULL
Definition: types.h:112
#define NTSTATUS
Definition: precomp.h:20
#define GetProcAddress(x, y)
Definition: compat.h:753
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
std::wstring STRING
Definition: fontsub.cpp:33
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
GLenum GLint GLuint mask
Definition: glext.h:6028
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLfloat GLfloat p
Definition: glext.h:8902
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
static const WCHAR emptyW[]
Definition: navigate.c:40
#define a
Definition: ke_i.h:78
#define b
Definition: ke_i.h:79
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
static char int
Definition: string.c:71
static void test_atoi(void)
Definition: string.c:3117
static size_t
Definition: string.c:56
static void test_atol(void)
Definition: string.c:3134
static HMODULE hntdll
Definition: string.c:30
#define NB_STR2LONGLONG
Definition: string.c:1071
static const str2long_t str2long[]
Definition: string.c:785
static void one_itoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:218
static void test_ulongtow(void)
Definition: string.c:400
static void test_ulonglongtow(void)
Definition: string.c:744
static LPSTR
Definition: string.c:39
static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:623
static void one_i64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:658
static const ulong2str_t ulong2str[]
Definition: string.c:116
#define ULL(a, b)
Definition: string.c:442
static int __cdecl intcomparefunc(const void *a, const void *b)
Definition: string.c:1168
static const ulonglong2str_t ulonglong2str[]
Definition: string.c:452
#define NB_ULONG2STR
Definition: string.c:215
static const void *static void *__cdecl * p_bsearch(void *, void *, size_t, size_t, int(__cdecl *compar)(const void *, const void *))
static INT
Definition: string.c:39
static void test__snprintf(void)
Definition: string.c:1273
static int __cdecl charcomparefunc(const void *a, const void *b)
Definition: string.c:1177
static void one_ui64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:708
static void one_ultoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:256
static void test_bsearch(void)
Definition: string.c:1255
static void one_itow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:293
static void one_ltoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:237
static void test_wtol(void)
Definition: string.c:933
static const str2longlong_t str2longlong[]
Definition: string.c:956
static void test_wcsrchr(void)
Definition: string.c:1134
static void test_wcschr(void)
Definition: string.c:1122
#define NB_STR2LONG
Definition: string.c:888
static void one_ltow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:328
static void one_ultow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:364
static void test_wcslwrupr(void)
Definition: string.c:1146
static void test_ulonglongtoa(void)
Definition: string.c:641
static int __cdecl strcomparefunc(const void *a, const void *b)
Definition: string.c:1186
static void one_i64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:594
static const char static void InitFunctionPtrs(void)
Definition: string.c:65
#define LARGE_STRI_BUFFER_LENGTH
Definition: string.c:106
static void test_qsort(void)
Definition: string.c:1196
static LPCSTR
Definition: string.c:33
static void test_ulongtoa(void)
Definition: string.c:275
static void test_atoi64(void)
Definition: string.c:1074
#define NB_ULONGLONG2STR
Definition: string.c:591
static void test_wtoi64(void)
Definition: string.c:1097
static const UNICODE_STRING BOOLEAN
Definition: string.c:31
static void test_wtoi(void)
Definition: string.c:891
long LONG
Definition: pedump.c:60
#define long
Definition: qsort.c:33
const WCHAR * str
#define WINAPIV
Definition: sdbpapi.h:64
#define memset(x, y, z)
Definition: compat.h:39
USHORT MaximumLength
Definition: env_spec_w32.h:370
LONG value
Definition: string.c:782
const char * str
Definition: string.c:781
LONGLONG value
Definition: string.c:952
const char * str
Definition: string.c:951
int overflow
Definition: string.c:953
ULONG value
Definition: string.c:110
const char * Buffer
Definition: string.c:111
int mask
Definition: string.c:112
int base
Definition: string.c:109
const char * Buffer
Definition: string.c:447
ULONGLONG value
Definition: string.c:446
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
struct _STRING * PSTRING
Definition: pdh_main.c:94
#define WINAPI
Definition: msvc.h:6
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185