ReactOS 0.4.15-dev-8058-ga7cbb60
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;
110 ULONG value;
111 const char *Buffer;
112 int mask; /* ntdll/msvcrt: 0x01=itoa, 0x02=ltoa, 0x04=ultoa */
113 /* 0x10=itow, 0x20=ltow, 0x40=ultow */
114} ulong2str_t;
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;
222 LPSTR result;
223
224 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
225 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
226 value = ulong2str->value;
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);
231 ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
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;
241 LPSTR result;
242
243 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
244 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
245 value = ulong2str->value;
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);
250 ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
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;
260 LPSTR result;
261
262 memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH);
263 dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0';
264 value = ulong2str->value;
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);
269 ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
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;
301 LPWSTR result;
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;
315 value = ulong2str->value;
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;
336 LPWSTR result;
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
351 value = ulong2str->value;
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;
372 LPWSTR result;
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
387 value = ulong2str->value;
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;
403 LPWSTR result;
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",
422 ulong2str[0].value, result);
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",
430 ulong2str[0].value, result);
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",
438 ulong2str[0].value, result);
439 }
440}
441
442#define ULL(a,b) (((ULONGLONG)(a) << 32) | (b))
443
444typedef struct {
445 int base;
446 ULONGLONG value;
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 */
450} ulonglong2str_t;
451
452static const ulonglong2str_t ulonglong2str[] = {
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{
596 LPSTR result;
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",
604 test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_str);
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) {
608 ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
609 "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
610 test_num, wine_dbgstr_longlong(ulonglong2str->value),
611 ulonglong2str->base, dest_str, ulonglong2str->Buffer);
612 } /* if */
613 } /* if */
614 } else {
615 ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
616 "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
617 test_num, wine_dbgstr_longlong(ulonglong2str->value),
618 ulonglong2str->base, dest_str, ulonglong2str->Buffer);
619 } /* if */
620}
621
622
623static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
624{
625 LPSTR result;
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",
633 test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_str);
634 ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0,
635 "(test %d): _ui64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
636 test_num, wine_dbgstr_longlong(ulonglong2str->value),
637 ulonglong2str->base, dest_str, ulonglong2str->Buffer);
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;
665 LPWSTR result;
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",
684 test_num, wine_dbgstr_longlong(ulonglong2str->value), ulonglong2str->base, result, dest_wstr);
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",
694 test_num, wine_dbgstr_longlong(ulonglong2str->value),
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",
701 test_num, wine_dbgstr_longlong(ulonglong2str->value),
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;
715 LPWSTR result;
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",
734 test_num, wine_dbgstr_longlong(ulonglong2str->value),
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",
738 test_num, wine_dbgstr_longlong(ulonglong2str->value),
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;
747 LPWSTR result;
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",
765 wine_dbgstr_longlong(ulonglong2str[0].value), result);
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",
774 wine_dbgstr_longlong(ulonglong2str[0].value), result);
775 }
776 } /* if */
777}
778
779
780typedef struct {
781 const char *str;
782 LONG value;
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;
952 LONGLONG value;
953 int overflow;
954} str2longlong_t;
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;
1077 LONGLONG result;
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),
1087 wine_dbgstr_longlong(str2longlong[test_num].value));
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),
1092 wine_dbgstr_longlong(str2longlong[test_num].value));
1093 }
1094}
1095
1096
1097static void test_wtoi64(void)
1098{
1099 int test_num;
1100 UNICODE_STRING uni;
1101 LONGLONG result;
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),
1112 wine_dbgstr_longlong(str2longlong[test_num].value));
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),
1117 wine_dbgstr_longlong(str2longlong[test_num].value));
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
1304START_TEST(string)
1305{
1306 InitFunctionPtrs();
1307
1308 if (p_ultoa)
1309 test_ulongtoa();
1310 if (p_ui64toa)
1311 test_ulonglongtoa();
1312 if (p_atoi64)
1313 test_atoi64();
1314 if (p_ultow)
1315 test_ulongtow();
1316 if (p_ui64tow)
1317 test_ulonglongtow();
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)
1329 test_wcslwrupr();
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)
1339 test__snprintf();
1340}
broken
#define broken(x)
Definition: _sntprintf.h:21
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
strcpy
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
__cdecl
#define __cdecl
Definition: accygwin.h:79
VOID
#define VOID
Definition: acefi.h:82
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
l
r l[0]
Definition: byte_order.h:168
Buffer
Definition: bufpool.h:45
NULL
#define NULL
Definition: types.h:112
NTSTATUS
#define NTSTATUS
Definition: precomp.h:21
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
lstrcmpA
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4194
PUNICODE_STRING
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
STRING
std::wstring STRING
Definition: fontsub.cpp:33
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
q
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
res
GLuint res
Definition: glext.h:9613
buffer
GLuint buffer
Definition: glext.h:5915
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
p
GLfloat GLfloat p
Definition: glext.h:8902
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
result
GLuint64EXT * result
Definition: glext.h:11304
i
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
j
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
emptyW
static const WCHAR emptyW[]
Definition: navigate.c:40
a
#define a
Definition: ke_i.h:78
b
#define b
Definition: ke_i.h:79
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
int
static char int
Definition: string.c:71
test_atoi
static void test_atoi(void)
Definition: string.c:3117
size_t
static size_t
Definition: string.c:56
test_atol
static void test_atol(void)
Definition: string.c:3134
hntdll
static HMODULE hntdll
Definition: string.c:30
NB_STR2LONGLONG
#define NB_STR2LONGLONG
Definition: string.c:1071
str2long
static const str2long_t str2long[]
Definition: string.c:785
one_itoa_test
static void one_itoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:218
test_ulongtow
static void test_ulongtow(void)
Definition: string.c:400
test_ulonglongtow
static void test_ulonglongtow(void)
Definition: string.c:744
LPSTR
static LPSTR
Definition: string.c:39
one_ui64toa_test
static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:623
one_i64tow_test
static void one_i64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:658
ulong2str
static const ulong2str_t ulong2str[]
Definition: string.c:116
ULL
#define ULL(a, b)
Definition: string.c:442
intcomparefunc
static int __cdecl intcomparefunc(const void *a, const void *b)
Definition: string.c:1168
ulonglong2str
static const ulonglong2str_t ulonglong2str[]
Definition: string.c:452
NB_ULONG2STR
#define NB_ULONG2STR
Definition: string.c:215
p_bsearch
static const void *static void *__cdecl * p_bsearch(void *, void *, size_t, size_t, int(__cdecl *compar)(const void *, const void *))
INT
static INT
Definition: string.c:39
test__snprintf
static void test__snprintf(void)
Definition: string.c:1273
charcomparefunc
static int __cdecl charcomparefunc(const void *a, const void *b)
Definition: string.c:1177
one_ui64tow_test
static void one_ui64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:708
one_ultoa_test
static void one_ultoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:256
test_bsearch
static void test_bsearch(void)
Definition: string.c:1255
one_itow_test
static void one_itow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:293
one_ltoa_test
static void one_ltoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:237
test_wtol
static void test_wtol(void)
Definition: string.c:933
str2longlong
static const str2longlong_t str2longlong[]
Definition: string.c:956
test_wcsrchr
static void test_wcsrchr(void)
Definition: string.c:1134
test_wcschr
static void test_wcschr(void)
Definition: string.c:1122
NB_STR2LONG
#define NB_STR2LONG
Definition: string.c:888
one_ltow_test
static void one_ltow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:328
one_ultow_test
static void one_ultow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:364
test_wcslwrupr
static void test_wcslwrupr(void)
Definition: string.c:1146
test_ulonglongtoa
static void test_ulonglongtoa(void)
Definition: string.c:641
strcomparefunc
static int __cdecl strcomparefunc(const void *a, const void *b)
Definition: string.c:1186
one_i64toa_test
static void one_i64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:594
InitFunctionPtrs
static const char static void InitFunctionPtrs(void)
Definition: string.c:65
LARGE_STRI_BUFFER_LENGTH
#define LARGE_STRI_BUFFER_LENGTH
Definition: string.c:106
test_qsort
static void test_qsort(void)
Definition: string.c:1196
LPCSTR
static LPCSTR
Definition: string.c:33
test_ulongtoa
static void test_ulongtoa(void)
Definition: string.c:275
test_atoi64
static void test_atoi64(void)
Definition: string.c:1074
NB_ULONGLONG2STR
#define NB_ULONGLONG2STR
Definition: string.c:591
test_wtoi64
static void test_wtoi64(void)
Definition: string.c:1097
BOOLEAN
static const UNICODE_STRING BOOLEAN
Definition: string.c:31
test_wtoi
static void test_wtoi(void)
Definition: string.c:891
ntdll_test.h
LONG
long LONG
Definition: pedump.c:60
long
#define long
Definition: qsort.c:33
str
const WCHAR * str
Definition: rpc_transport.c:2724
WINAPIV
#define WINAPIV
Definition: sdbpapi.h:64
memset
#define memset(x, y, z)
Definition: compat.h:39
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
str2long_t
Definition: string.c:780
str2long_t::value
LONG value
Definition: string.c:782
str2long_t::str
const char * str
Definition: string.c:781
str2longlong_t
Definition: string.c:950
str2longlong_t::value
LONGLONG value
Definition: string.c:952
str2longlong_t::str
const char * str
Definition: string.c:951
str2longlong_t::overflow
int overflow
Definition: string.c:953
ulong2str_t
Definition: string.c:108
ulong2str_t::value
ULONG value
Definition: string.c:110
ulong2str_t::Buffer
const char * Buffer
Definition: string.c:111
ulong2str_t::mask
int mask
Definition: string.c:112
ulong2str_t::base
int base
Definition: string.c:109
ulonglong2str_t
Definition: string.c:444
ulonglong2str_t::Buffer
const char * Buffer
Definition: string.c:447
ulonglong2str_t::mask
int mask
Definition: string.c:448
ulonglong2str_t::value
ULONGLONG value
Definition: string.c:446
ulonglong2str_t::base
int base
Definition: string.c:445
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
ULONG
uint32_t ULONG
Definition: typedefs.h:59
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
PSTRING
struct _STRING * PSTRING
value
Definition: pdh_main.c:94
WINAPI
#define WINAPI
Definition: msvc.h:6
LPSTR
char * LPSTR
Definition: xmlstorage.h:182
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185