ReactOS  0.4.14-dev-384-g5b37caa
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 */
30 static HMODULE hntdll = 0;
31 static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
32 static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);
33 static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING,LPCSTR);
34 static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
35 
36 static int (WINAPIV *patoi)(const char *);
37 static long (WINAPIV *patol)(const char *);
38 static LONGLONG (WINAPIV *p_atoi64)(const char *);
39 static LPSTR (WINAPIV *p_itoa)(int, LPSTR, INT);
40 static LPSTR (WINAPIV *p_ltoa)(LONG, LPSTR, INT);
41 static LPSTR (WINAPIV *p_ultoa)(ULONG, LPSTR, INT);
42 static LPSTR (WINAPIV *p_i64toa)(LONGLONG, LPSTR, INT);
43 static LPSTR (WINAPIV *p_ui64toa)(ULONGLONG, LPSTR, INT);
44 
45 static int (WINAPIV *p_wtoi)(LPWSTR);
46 static long (WINAPIV *p_wtol)(LPWSTR);
47 static LONGLONG (WINAPIV *p_wtoi64)(LPWSTR);
48 static LPWSTR (WINAPIV *p_itow)(int, LPWSTR, int);
49 static LPWSTR (WINAPIV *p_ltow)(LONG, LPWSTR, INT);
50 static LPWSTR (WINAPIV *p_ultow)(ULONG, LPWSTR, INT);
51 static LPWSTR (WINAPIV *p_i64tow)(LONGLONG, LPWSTR, INT);
52 static LPWSTR (WINAPIV *p_ui64tow)(ULONGLONG, LPWSTR, INT);
53 
54 static LPWSTR (__cdecl *p_wcslwr)(LPWSTR);
55 static LPWSTR (__cdecl *p_wcsupr)(LPWSTR);
56 
57 static LPWSTR (WINAPIV *p_wcschr)(LPCWSTR, WCHAR);
58 static LPWSTR (WINAPIV *p_wcsrchr)(LPCWSTR, WCHAR);
59 
60 static void (__cdecl *p_qsort)(void *,size_t,size_t, int(__cdecl *compar)(const void *, const void *) );
61 static void* (__cdecl *p_bsearch)(void *,void*,size_t,size_t, int(__cdecl *compar)(const void *, const void *) );
62 static int (WINAPIV *p__snprintf)(char *, size_t, const char *, ...);
63 
64 
65 static 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 
108 typedef 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 */
114 } ulong2str_t;
115 
116 static 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 
218 static 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);
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 
237 static 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);
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 
256 static 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);
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 
275 static 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 
293 static 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 
328 static 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 
364 static 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 
400 static 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 
444 typedef 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 
452 static 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 
594 static 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",
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",
611  ulonglong2str->base, dest_str, ulonglong2str->Buffer);
612  } /* if */
613  } /* if */
614  } else {
616  "(test %d): _i64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
618  ulonglong2str->base, dest_str, ulonglong2str->Buffer);
619  } /* if */
620 }
621 
622 
623 static 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",
635  "(test %d): _ui64toa(%s, [out], %d) assigns string \"%s\", expected: \"%s\"\n",
637  ulonglong2str->base, dest_str, ulonglong2str->Buffer);
638 }
639 
640 
641 static 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 
658 static 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",
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 
708 static 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",
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 
744 static 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",
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 
780 typedef struct {
781  const char *str;
783 } str2long_t;
784 
785 static 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 
891 static 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 
907 static 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 
920 static 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 
933 static 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 
950 typedef struct {
951  const char *str;
953  int overflow;
955 
956 static 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 
1074 static 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),
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 
1097 static 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),
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 
1122 static 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 
1134 static 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 
1146 static 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 
1168 static 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 
1177 static 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 
1186 static 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 
1196 static 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 
1255 static 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 
1273 static 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 
1304 START_TEST(string)
1305 {
1306  InitFunctionPtrs();
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)
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 }
static void test_ulonglongtoa(void)
Definition: string.c:641
static INT
Definition: string.c:39
static void test_atol(void)
Definition: string.c:920
static const str2longlong_t str2longlong[]
Definition: string.c:956
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
static void one_itoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:218
#define __cdecl
Definition: accygwin.h:79
static void test_wtol(void)
Definition: string.c:933
USHORT MaximumLength
Definition: env_spec_w32.h:370
static void one_ltoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:237
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static const char static void InitFunctionPtrs(void)
Definition: string.c:65
static const str2long_t str2long[]
Definition: string.c:785
#define ULL(a, b)
Definition: string.c:442
static void(__cdecl *p_qsort)(void *
static long(WINAPIV *patol)(const char *)
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
static LPSTR
Definition: string.c:39
#define U(x)
Definition: wordpad.c:44
static NTSTATUS(WINAPI *pRtlUnicodeStringToAnsiString)(STRING *
static void test_wcsrchr(void)
Definition: string.c:1134
#define NB_ULONGLONG2STR
Definition: string.c:591
static void test_atoi64(void)
Definition: string.c:1074
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
GLuint buffer
Definition: glext.h:5915
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
static const void *static void *__cdecl * p_bsearch(void *, void *, size_t, size_t, int(__cdecl *compar)(const void *, const void *))
static void one_i64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:594
const char * str
Definition: string.c:951
char * LPSTR
Definition: xmlstorage.h:182
#define NB_ULONG2STR
Definition: string.c:215
static int __cdecl strcomparefunc(const void *a, const void *b)
Definition: string.c:1186
static void test__snprintf(void)
Definition: string.c:1273
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
GLenum GLint GLuint mask
Definition: glext.h:6028
static void test_bsearch(void)
Definition: string.c:1255
long LONG
Definition: pedump.c:60
#define a
Definition: ke_i.h:78
struct _STRING * PSTRING
static void one_ultow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:364
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
static void test_ulongtow(void)
Definition: string.c:400
static void one_ui64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:708
const WCHAR * str
static WCHAR
Definition: string.c:57
static void one_ltow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:328
smooth NULL
Definition: ftsmooth.c:416
static size_t
Definition: string.c:56
static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:623
Definition: bufpool.h:45
static void test_wcslwrupr(void)
Definition: string.c:1146
LONG value
Definition: string.c:782
static void one_ultoa_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:256
static void test_ulonglongtow(void)
Definition: string.c:744
static void test_wtoi(void)
Definition: string.c:891
LONGLONG value
Definition: string.c:952
#define b
Definition: ke_i.h:79
static void test_qsort(void)
Definition: string.c:1196
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
r l[0]
Definition: byte_order.h:167
int overflow
Definition: string.c:953
static const ulong2str_t ulong2str[]
Definition: string.c:116
static const ulonglong2str_t ulonglong2str[]
Definition: string.c:452
int64_t LONGLONG
Definition: typedefs.h:66
ULONGLONG value
Definition: string.c:446
ULONG value
Definition: string.c:110
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
__wchar_t WCHAR
Definition: xmlstorage.h:180
uint64_t ULONGLONG
Definition: typedefs.h:65
#define WINAPI
Definition: msvc.h:8
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
std::wstring STRING
Definition: fontsub.cpp:33
int mask
Definition: string.c:112
#define LARGE_STRI_BUFFER_LENGTH
Definition: string.c:106
static LPCSTR
Definition: string.c:33
static void test_ulongtoa(void)
Definition: string.c:275
GLsizei const GLfloat * value
Definition: glext.h:6069
static const UNICODE_STRING BOOLEAN
Definition: string.c:31
#define WINAPIV
Definition: sdbpapi.h:64
#define broken(x)
Definition: _sntprintf.h:21
static HMODULE hntdll
Definition: string.c:30
static void one_itow_test(int test_num, const ulong2str_t *ulong2str)
Definition: string.c:293
START_TEST(string)
Definition: string.c:3859
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
static const WCHAR emptyW[]
Definition: navigate.c:40
#define ok(value,...)
Definition: atltest.h:57
static char int
Definition: string.c:71
static LPCWSTR
Definition: string.c:46
static void test_atoi(void)
Definition: string.c:907
static void test_wtoi64(void)
Definition: string.c:1097
#define NB_STR2LONG
Definition: string.c:888
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
const char * Buffer
Definition: string.c:447
int base
Definition: string.c:109
static VOID(WINAPI *pRtlFreeAnsiString)(PSTRING)
GLuint res
Definition: glext.h:9613
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
static int __cdecl charcomparefunc(const void *a, const void *b)
Definition: string.c:1177
unsigned int ULONG
Definition: retypes.h:1
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
const char * str
Definition: string.c:781
#define GetProcAddress(x, y)
Definition: compat.h:418
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define NB_STR2LONGLONG
Definition: string.c:1071
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static void one_i64tow_test(int test_num, const ulonglong2str_t *ulonglong2str)
Definition: string.c:658
GLuint64EXT * result
Definition: glext.h:11304
#define memset(x, y, z)
Definition: compat.h:39
static int __cdecl intcomparefunc(const void *a, const void *b)
Definition: string.c:1168
#define UL
Definition: tui.h:83
static void test_wcschr(void)
Definition: string.c:1122
static LONGLONG(WINAPIV *p_atoi64)(const char *)
const char * Buffer
Definition: string.c:111
static LPWSTR
Definition: string.c:48