From 93189f2395accdf661fbf4d2b3b81649d5b1ee76 Mon Sep 17 00:00:00 2001 From: Thomas Mertes Date: Tue, 18 Mar 2003 18:27:19 +0000 Subject: [PATCH] Tests for _itoa, _ltoa, _ultoa, _i64toa, _ui64toa, _itow, _ltow, _ultow, _i64tow, _ui64tow, _atoi64, _wtoi, _wtol, _wtoi64. --- dlls/ntdll/tests/.cvsignore | 1 + dlls/ntdll/tests/Makefile.in | 3 +- dlls/ntdll/tests/string.c | 1082 ++++++++++++++++++++++++++++++++++ 3 files changed, 1085 insertions(+), 1 deletion(-) create mode 100644 dlls/ntdll/tests/string.c diff --git a/dlls/ntdll/tests/.cvsignore b/dlls/ntdll/tests/.cvsignore index f5f16015d70..007df7377b5 100644 --- a/dlls/ntdll/tests/.cvsignore +++ b/dlls/ntdll/tests/.cvsignore @@ -5,4 +5,5 @@ large_int.ok ntdll_test.exe.spec.c rtlbitmap.ok rtlstr.ok +string.ok testlist.c diff --git a/dlls/ntdll/tests/Makefile.in b/dlls/ntdll/tests/Makefile.in index 64ee289d7d8..872018abab1 100644 --- a/dlls/ntdll/tests/Makefile.in +++ b/dlls/ntdll/tests/Makefile.in @@ -10,7 +10,8 @@ CTESTS = \ generated.c \ large_int.c \ rtlbitmap.c \ - rtlstr.c + rtlstr.c \ + string.c @MAKE_TEST_RULES@ diff --git a/dlls/ntdll/tests/string.c b/dlls/ntdll/tests/string.c new file mode 100644 index 00000000000..1754a75b80b --- /dev/null +++ b/dlls/ntdll/tests/string.c @@ -0,0 +1,1082 @@ +/* Unit test suite for string functions and some wcstring functions + * + * Copyright 2003 Thomas Mertes + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NOTES + * We use function pointers here as there is no import library for NTDLL on + * windows. + */ + +#include + +#include "winbase.h" +#include "wine/test.h" +#include "winnt.h" +#include "winnls.h" +#include "winternl.h" + +/* Function ptrs for ntdll calls */ +static HMODULE hntdll = 0; +static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN); +static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING); +static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING,LPCSTR); +static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING); + +static int (WINAPIV *patoi)(const char *); +static long (WINAPIV *patol)(const char *); +static LONGLONG (WINAPIV *p_atoi64)(const char *); +static LPSTR (WINAPIV *p_itoa)(int, LPSTR, INT); +static LPSTR (WINAPIV *p_ltoa)(long, LPSTR, INT); +static LPSTR (WINAPIV *p_ultoa)(unsigned long, LPSTR, INT); +static LPSTR (WINAPIV *p_i64toa)(LONGLONG, LPSTR, INT); +static LPSTR (WINAPIV *p_ui64toa)(ULONGLONG, LPSTR, INT); + +static int (WINAPIV *p_wtoi)(LPWSTR); +static long (WINAPIV *p_wtol)(LPWSTR); +static LONGLONG (WINAPIV *p_wtoi64)(LPWSTR); +static LPWSTR (WINAPIV *p_itow)(int, LPWSTR, int); +static LPWSTR (WINAPIV *p_ltow)(long, LPWSTR, INT); +static LPWSTR (WINAPIV *p_ultow)(unsigned long, LPWSTR, INT); +static LPWSTR (WINAPIV *p_i64tow)(LONGLONG, LPWSTR, INT); +static LPWSTR (WINAPIV *p_ui64tow)(ULONGLONG, LPWSTR, INT); + +static long (WINAPIV *pwcstol)(LPCWSTR, LPWSTR *, INT); +static ULONG (WINAPIV *pwcstoul)(LPCWSTR, LPWSTR *, INT); + + +static void InitFunctionPtrs() +{ + hntdll = LoadLibraryA("ntdll.dll"); + ok(hntdll != 0, "LoadLibrary failed"); + if (hntdll) { + pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString"); + pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString"); + pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz"); + pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString"); + + patoi = (void *)GetProcAddress(hntdll, "atoi"); + patol = (void *)GetProcAddress(hntdll, "atol"); + p_atoi64 = (void *)GetProcAddress(hntdll, "_atoi64"); + p_itoa = (void *)GetProcAddress(hntdll, "_itoa"); + p_ltoa = (void *)GetProcAddress(hntdll, "_ltoa"); + p_ultoa = (void *)GetProcAddress(hntdll, "_ultoa"); + p_i64toa = (void *)GetProcAddress(hntdll, "_i64toa"); + p_ui64toa = (void *)GetProcAddress(hntdll, "_ui64toa"); + + p_wtoi = (void *)GetProcAddress(hntdll, "_wtoi"); + p_wtol = (void *)GetProcAddress(hntdll, "_wtol"); + p_wtoi64 = (void *)GetProcAddress(hntdll, "_wtoi64"); + p_itow = (void *)GetProcAddress(hntdll, "_itow"); + p_ltow = (void *)GetProcAddress(hntdll, "_ltow"); + p_ultow = (void *)GetProcAddress(hntdll, "_ultow"); + p_i64tow = (void *)GetProcAddress(hntdll, "_i64tow"); + p_ui64tow = (void *)GetProcAddress(hntdll, "_ui64tow"); + + pwcstol = (void *)GetProcAddress(hntdll, "wcstol"); + pwcstoul = (void *)GetProcAddress(hntdll, "wcstoul"); + } /* if */ +} + + +#define LARGE_STRI_BUFFER_LENGTH 67 + +typedef struct { + int base; + ULONG value; + char *Buffer; + int mask; /* ntdll/msvcrt: 0x01=itoa, 0x02=ltoa, 0x04=ultoa */ + /* 0x10=itow, 0x20=ltow, 0x40=ultow */ +} ulong2str_t; + +static const ulong2str_t ulong2str[] = { + {10, 123, "123\0---------------------------------------------------------------", 0x77}, + + { 2, 0x80000000U, "10000000000000000000000000000000\0----------------------------------", 0x67}, + { 2, -2147483647, "10000000000000000000000000000001\0----------------------------------", 0x67}, + { 2, -65537, "11111111111111101111111111111111\0----------------------------------", 0x67}, + { 2, -65536, "11111111111111110000000000000000\0----------------------------------", 0x67}, + { 2, -65535, "11111111111111110000000000000001\0----------------------------------", 0x67}, + { 2, -32768, "11111111111111111000000000000000\0----------------------------------", 0x67}, + { 2, -32767, "11111111111111111000000000000001\0----------------------------------", 0x67}, + { 2, -2, "11111111111111111111111111111110\0----------------------------------", 0x67}, + { 2, -1, "11111111111111111111111111111111\0----------------------------------", 0x67}, + { 2, 0, "0\0-----------------------------------------------------------------", 0x77}, + { 2, 1, "1\0-----------------------------------------------------------------", 0x77}, + { 2, 10, "1010\0--------------------------------------------------------------", 0x77}, + { 2, 100, "1100100\0-----------------------------------------------------------", 0x77}, + { 2, 1000, "1111101000\0--------------------------------------------------------", 0x77}, + { 2, 10000, "10011100010000\0----------------------------------------------------", 0x77}, + { 2, 32767, "111111111111111\0---------------------------------------------------", 0x77}, + { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x77}, + { 2, 65535, "1111111111111111\0--------------------------------------------------", 0x77}, + { 2, 100000, "11000011010100000\0-------------------------------------------------", 0x77}, + { 2, 234567, "111001010001000111\0------------------------------------------------", 0x77}, + { 2, 300000, "1001001001111100000\0-----------------------------------------------", 0x77}, + { 2, 524287, "1111111111111111111\0-----------------------------------------------", 0x77}, + { 2, 524288, "10000000000000000000\0----------------------------------------------", 0x67}, + { 2, 1000000, "11110100001001000000\0----------------------------------------------", 0x67}, + { 2, 10000000, "100110001001011010000000\0------------------------------------------", 0x67}, + { 2, 100000000, "101111101011110000100000000\0---------------------------------------", 0x67}, + { 2, 1000000000, "111011100110101100101000000000\0------------------------------------", 0x67}, + { 2, 1073741823, "111111111111111111111111111111\0------------------------------------", 0x67}, + { 2, 2147483646, "1111111111111111111111111111110\0-----------------------------------", 0x67}, + { 2, 2147483647, "1111111111111111111111111111111\0-----------------------------------", 0x67}, + { 2, 2147483648U, "10000000000000000000000000000000\0----------------------------------", 0x67}, + { 2, 2147483649U, "10000000000000000000000000000001\0----------------------------------", 0x67}, + { 2, 4294967294U, "11111111111111111111111111111110\0----------------------------------", 0x67}, + { 2, 0xFFFFFFFF, "11111111111111111111111111111111\0----------------------------------", 0x67}, + + { 8, 0x80000000U, "20000000000\0-------------------------------------------------------", 0x77}, + { 8, -2147483647, "20000000001\0-------------------------------------------------------", 0x77}, + { 8, -2, "37777777776\0-------------------------------------------------------", 0x77}, + { 8, -1, "37777777777\0-------------------------------------------------------", 0x77}, + { 8, 0, "0\0-----------------------------------------------------------------", 0x77}, + { 8, 1, "1\0-----------------------------------------------------------------", 0x77}, + { 8, 2147483646, "17777777776\0-------------------------------------------------------", 0x77}, + { 8, 2147483647, "17777777777\0-------------------------------------------------------", 0x77}, + { 8, 2147483648U, "20000000000\0-------------------------------------------------------", 0x77}, + { 8, 2147483649U, "20000000001\0-------------------------------------------------------", 0x77}, + { 8, 4294967294U, "37777777776\0-------------------------------------------------------", 0x77}, + { 8, 4294967295U, "37777777777\0-------------------------------------------------------", 0x77}, + + {10, 0x80000000U, "-2147483648\0-------------------------------------------------------", 0x33}, + {10, 0x80000000U, "2147483648\0--------------------------------------------------------", 0x44}, + {10, -2147483647, "-2147483647\0-------------------------------------------------------", 0x33}, + {10, -2147483647, "2147483649\0--------------------------------------------------------", 0x44}, + {10, -2, "-2\0----------------------------------------------------------------", 0x33}, + {10, -2, "4294967294\0--------------------------------------------------------", 0x44}, + {10, -1, "-1\0----------------------------------------------------------------", 0x33}, + {10, -1, "4294967295\0--------------------------------------------------------", 0x44}, + {10, 0, "0\0-----------------------------------------------------------------", 0x77}, + {10, 1, "1\0-----------------------------------------------------------------", 0x77}, + {10, 12, "12\0----------------------------------------------------------------", 0x77}, + {10, 123, "123\0---------------------------------------------------------------", 0x77}, + {10, 1234, "1234\0--------------------------------------------------------------", 0x77}, + {10, 12345, "12345\0-------------------------------------------------------------", 0x77}, + {10, 123456, "123456\0------------------------------------------------------------", 0x77}, + {10, 1234567, "1234567\0-----------------------------------------------------------", 0x77}, + {10, 12345678, "12345678\0----------------------------------------------------------", 0x77}, + {10, 123456789, "123456789\0---------------------------------------------------------", 0x77}, + {10, 2147483646, "2147483646\0--------------------------------------------------------", 0x77}, + {10, 2147483647, "2147483647\0--------------------------------------------------------", 0x77}, + {10, 2147483648U, "-2147483648\0-------------------------------------------------------", 0x33}, + {10, 2147483648U, "2147483648\0--------------------------------------------------------", 0x44}, + {10, 2147483649U, "-2147483647\0-------------------------------------------------------", 0x33}, + {10, 2147483649U, "2147483649\0--------------------------------------------------------", 0x44}, + {10, 4294967294U, "-2\0----------------------------------------------------------------", 0x33}, + {10, 4294967294U, "4294967294\0--------------------------------------------------------", 0x44}, + {10, 4294967295U, "-1\0----------------------------------------------------------------", 0x33}, + {10, 4294967295U, "4294967295\0--------------------------------------------------------", 0x44}, + + {16, 0, "0\0-----------------------------------------------------------------", 0x77}, + {16, 1, "1\0-----------------------------------------------------------------", 0x77}, + {16, 2147483646, "7ffffffe\0----------------------------------------------------------", 0x77}, + {16, 2147483647, "7fffffff\0----------------------------------------------------------", 0x77}, + {16, 0x80000000, "80000000\0----------------------------------------------------------", 0x77}, + {16, 0x80000001, "80000001\0----------------------------------------------------------", 0x77}, + {16, 0xFFFFFFFE, "fffffffe\0----------------------------------------------------------", 0x77}, + {16, 0xFFFFFFFF, "ffffffff\0----------------------------------------------------------", 0x77}, + + { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x77}, + { 2, 65536, "10000000000000000\0-------------------------------------------------", 0x77}, + { 2, 131072, "100000000000000000\0------------------------------------------------", 0x77}, + {16, 0xffffffff, "ffffffff\0----------------------------------------------------------", 0x77}, + {16, 0xa, "a\0-----------------------------------------------------------------", 0x77}, + {16, 0, "0\0-----------------------------------------------------------------", 0x77}, + {20, 3368421, "111111\0------------------------------------------------------------", 0x77}, + {36, 62193781, "111111\0------------------------------------------------------------", 0x77}, + {37, 71270178, "111111\0------------------------------------------------------------", 0x77}, +}; +#define NB_ULONG2STR (sizeof(ulong2str)/sizeof(*ulong2str)) + + +static void one_itoa_test(int test_num, const ulong2str_t *ulong2str) +{ + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + int value; + LPSTR result; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + value = ulong2str->value; + result = p_itoa(value, dest_str, ulong2str->base); + ok(result == dest_str, + "(test %d): _itoa(%d, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_str); + ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _itoa(%d, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, dest_str, ulong2str->Buffer); +} + + +static void one_ltoa_test(int test_num, const ulong2str_t *ulong2str) +{ + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + long value; + LPSTR result; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + value = ulong2str->value; + result = p_ltoa(ulong2str->value, dest_str, ulong2str->base); + ok(result == dest_str, + "(test %d): _ltoa(%ld, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_str); + ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _ltoa(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, dest_str, ulong2str->Buffer); +} + + +static void one_ultoa_test(int test_num, const ulong2str_t *ulong2str) +{ + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + unsigned long value; + LPSTR result; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + value = ulong2str->value; + result = p_ultoa(ulong2str->value, dest_str, ulong2str->base); + ok(result == dest_str, + "(test %d): _ultoa(%lu, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_str); + ok(memcmp(dest_str, ulong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _ultoa(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, dest_str, ulong2str->Buffer); +} + + +static void test_ulongtoa(void) +{ + int test_num; + + for (test_num = 0; test_num < NB_ULONG2STR; test_num++) { + if (ulong2str[test_num].mask & 0x01) { + one_itoa_test(test_num, &ulong2str[test_num]); + } /* if */ + if (ulong2str[test_num].mask & 0x02) { + one_ltoa_test(test_num, &ulong2str[test_num]); + } /* if */ + if (ulong2str[test_num].mask & 0x04) { + one_ultoa_test(test_num, &ulong2str[test_num]); + } /* if */ + } /* for */ +} + + +static void one_itow_test(int test_num, const ulong2str_t *ulong2str) +{ + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + int value; + LPWSTR result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str->Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + dest_wstr[pos] = '-'; + } /* for */ + dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR); + unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR); + unicode_string.Buffer = dest_wstr; + value = ulong2str->value; + result = p_itow(value, dest_wstr, ulong2str->base); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + ok(result == dest_wstr, + "(test %d): _itow(%d, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_wstr); + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _itow(%d, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer); + pRtlFreeAnsiString(&ansi_str); +} + + +static void one_ltow_test(int test_num, const ulong2str_t *ulong2str) +{ + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + long value; + LPWSTR result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str->Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + dest_wstr[pos] = '-'; + } /* for */ + dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR); + unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR); + unicode_string.Buffer = dest_wstr; + + value = ulong2str->value; + result = p_ltow(value, dest_wstr, ulong2str->base); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + ok(result == dest_wstr, + "(test %d): _ltow(%ld, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_wstr); + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _ltow(%ld, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer); + pRtlFreeAnsiString(&ansi_str); +} + + +static void one_ultow_test(int test_num, const ulong2str_t *ulong2str) +{ + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + unsigned long value; + LPWSTR result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str->Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + dest_wstr[pos] = '-'; + } /* for */ + dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR); + unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR); + unicode_string.Buffer = dest_wstr; + + value = ulong2str->value; + result = p_ultow(value, dest_wstr, ulong2str->base); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + ok(result == dest_wstr, + "(test %d): _ultow(%lu, [out], %d) has result %p, expected: %p", + test_num, value, ulong2str->base, result, dest_wstr); + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _ultow(%lu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, value, ulong2str->base, ansi_str.Buffer, ulong2str->Buffer); + pRtlFreeAnsiString(&ansi_str); +} + + +static void test_ulongtow(void) +{ + int test_num; + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + LPWSTR result; + + for (test_num = 0; test_num < NB_ULONG2STR; test_num++) { + if (ulong2str[test_num].mask & 0x10) { + one_itow_test(test_num, &ulong2str[test_num]); + } /* if */ + if (ulong2str[test_num].mask & 0x20) { + one_ltow_test(test_num, &ulong2str[test_num]); + } /* if */ + if (ulong2str[test_num].mask & 0x40) { + one_ultow_test(test_num, &ulong2str[test_num]); + } /* if */ + } /* for */ + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str[0].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_itow(ulong2str[0].value, NULL, 10); + ok(result == NULL, + "(test a): _itow(%ld, NULL, 10) has result %p, expected: NULL", + ulong2str[0].value, result); + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str[0].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_ltow(ulong2str[0].value, NULL, 10); + ok(result == NULL, + "(test b): _ltow(%ld, NULL, 10) has result %p, expected: NULL", + ulong2str[0].value, result); + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str[0].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_ultow(ulong2str[0].value, NULL, 10); + ok(result == NULL, + "(test c): _ultow(%ld, NULL, 10) has result %p, expected: NULL", + ulong2str[0].value, result); +} + + +typedef struct { + int base; + ULONGLONG value; + char *Buffer; + int mask; /* ntdll/msvcrt: 0x01=i64toa, 0x02=ui64toa, 0x04=wrong _i64toa try next example */ + /* 0x10=i64tow, 0x20=ui64tow, 0x40=wrong _i64tow try next example */ +} ulonglong2str_t; + +static const ulonglong2str_t ulonglong2str[] = { + {10, 123, "123\0---------------------------------------------------------------", 0x33}, + + { 2, 0x80000000U, "10000000000000000000000000000000\0----------------------------------", 0x33}, + { 2, -2147483647, "1111111111111111111111111111111110000000000000000000000000000001\0--", 0x33}, + { 2, -65537, "1111111111111111111111111111111111111111111111101111111111111111\0--", 0x33}, + { 2, -65536, "1111111111111111111111111111111111111111111111110000000000000000\0--", 0x33}, + { 2, -65535, "1111111111111111111111111111111111111111111111110000000000000001\0--", 0x33}, + { 2, -32768, "1111111111111111111111111111111111111111111111111000000000000000\0--", 0x33}, + { 2, -32767, "1111111111111111111111111111111111111111111111111000000000000001\0--", 0x33}, + { 2, -2, "1111111111111111111111111111111111111111111111111111111111111110\0--", 0x33}, + { 2, -1, "1111111111111111111111111111111111111111111111111111111111111111\0--", 0x33}, + { 2, 0, "0\0-----------------------------------------------------------------", 0x33}, + { 2, 1, "1\0-----------------------------------------------------------------", 0x33}, + { 2, 10, "1010\0--------------------------------------------------------------", 0x33}, + { 2, 100, "1100100\0-----------------------------------------------------------", 0x33}, + { 2, 1000, "1111101000\0--------------------------------------------------------", 0x33}, + { 2, 10000, "10011100010000\0----------------------------------------------------", 0x33}, + { 2, 32767, "111111111111111\0---------------------------------------------------", 0x33}, + { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x33}, + { 2, 65535, "1111111111111111\0--------------------------------------------------", 0x33}, + { 2, 100000, "11000011010100000\0-------------------------------------------------", 0x33}, + { 2, 234567, "111001010001000111\0------------------------------------------------", 0x33}, + { 2, 300000, "1001001001111100000\0-----------------------------------------------", 0x33}, + { 2, 524287, "1111111111111111111\0-----------------------------------------------", 0x33}, + { 2, 524288, "10000000000000000000\0----------------------------------------------", 0x33}, + { 2, 1000000, "11110100001001000000\0----------------------------------------------", 0x33}, + { 2, 10000000, "100110001001011010000000\0------------------------------------------", 0x33}, + { 2, 100000000, "101111101011110000100000000\0---------------------------------------", 0x33}, + { 2, 1000000000, "111011100110101100101000000000\0------------------------------------", 0x33}, + { 2, 1073741823, "111111111111111111111111111111\0------------------------------------", 0x33}, + { 2, 2147483646, "1111111111111111111111111111110\0-----------------------------------", 0x33}, + { 2, 2147483647, "1111111111111111111111111111111\0-----------------------------------", 0x33}, + { 2, 2147483648U, "10000000000000000000000000000000\0----------------------------------", 0x33}, + { 2, 2147483649U, "10000000000000000000000000000001\0----------------------------------", 0x33}, + { 2, 4294967294U, "11111111111111111111111111111110\0----------------------------------", 0x33}, + { 2, 0xFFFFFFFF, "11111111111111111111111111111111\0----------------------------------", 0x33}, + { 2, 0x1FFFFFFFF, "111111111111111111111111111111111\0---------------------------------", 0x33}, + { 2, 10000000000, "1001010100000010111110010000000000\0--------------------------------", 0x33}, + { 2, 0x3FFFFFFFF, "1111111111111111111111111111111111\0--------------------------------", 0x33}, + { 2, 0x7FFFFFFFF, "11111111111111111111111111111111111\0-------------------------------", 0x33}, + { 2, 0xFFFFFFFFF, "111111111111111111111111111111111111\0------------------------------", 0x33}, + { 2, 100000000000, "1011101001000011101101110100000000000\0-----------------------------", 0x33}, + { 2, 0x1FFFFFFFFF, "1111111111111111111111111111111111111\0-----------------------------", 0x33}, + { 2, 0x3FFFFFFFFF, "11111111111111111111111111111111111111\0----------------------------", 0x33}, + { 2, 0x7FFFFFFFFF, "111111111111111111111111111111111111111\0---------------------------", 0x33}, + { 2, 0xFFFFFFFFFF, "1111111111111111111111111111111111111111\0--------------------------", 0x33}, + + { 8, 0x80000000U, "20000000000\0-------------------------------------------------------", 0x33}, + { 8, -2147483647, "1777777777760000000001\0--------------------------------------------", 0x33}, + { 8, -2, "1777777777777777777776\0--------------------------------------------", 0x33}, + { 8, -1, "1777777777777777777777\0--------------------------------------------", 0x33}, + { 8, 0, "0\0-----------------------------------------------------------------", 0x33}, + { 8, 1, "1\0-----------------------------------------------------------------", 0x33}, + { 8, 2147483646, "17777777776\0-------------------------------------------------------", 0x33}, + { 8, 2147483647, "17777777777\0-------------------------------------------------------", 0x33}, + { 8, 2147483648U, "20000000000\0-------------------------------------------------------", 0x33}, + { 8, 2147483649U, "20000000001\0-------------------------------------------------------", 0x33}, + { 8, 4294967294U, "37777777776\0-------------------------------------------------------", 0x33}, + { 8, 4294967295U, "37777777777\0-------------------------------------------------------", 0x33}, + + {10, 0x80000000U, "2147483648\0--------------------------------------------------------", 0x33}, + {10, -2147483647, "-2147483647\0-------------------------------------------------------", 0x55}, + {10, -2147483647, "-18446744071562067969\0---------------------------------------------", 0x00}, + {10, -2147483647, "18446744071562067969\0----------------------------------------------", 0x22}, + {10, -2, "-2\0----------------------------------------------------------------", 0x55}, + {10, -2, "-18446744073709551614\0---------------------------------------------", 0x00}, + {10, -2, "18446744073709551614\0----------------------------------------------", 0x22}, + {10, -1, "-1\0----------------------------------------------------------------", 0x55}, + {10, -1, "-18446744073709551615\0---------------------------------------------", 0x00}, + {10, -1, "18446744073709551615\0----------------------------------------------", 0x22}, + {10, 0, "0\0-----------------------------------------------------------------", 0x33}, + {10, 1, "1\0-----------------------------------------------------------------", 0x33}, + {10, 12, "12\0----------------------------------------------------------------", 0x33}, + {10, 123, "123\0---------------------------------------------------------------", 0x33}, + {10, 1234, "1234\0--------------------------------------------------------------", 0x33}, + {10, 12345, "12345\0-------------------------------------------------------------", 0x33}, + {10, 123456, "123456\0------------------------------------------------------------", 0x33}, + {10, 1234567, "1234567\0-----------------------------------------------------------", 0x33}, + {10, 12345678, "12345678\0----------------------------------------------------------", 0x33}, + {10, 123456789, "123456789\0---------------------------------------------------------", 0x33}, + {10, 2147483646, "2147483646\0--------------------------------------------------------", 0x33}, + {10, 2147483647, "2147483647\0--------------------------------------------------------", 0x33}, + {10, 2147483648U, "2147483648\0--------------------------------------------------------", 0x33}, + {10, 2147483649U, "2147483649\0--------------------------------------------------------", 0x33}, + {10, 4294967294U, "4294967294\0--------------------------------------------------------", 0x33}, + {10, 4294967295U, "4294967295\0--------------------------------------------------------", 0x33}, + {10, 12345678901U, "12345678901\0-------------------------------------------------------", 0x33}, + {10, 987654321012U, "987654321012\0------------------------------------------------------", 0x33}, + {10, 1928374656574U, "1928374656574\0-----------------------------------------------------", 0x33}, + {10, 0xBADCAFEFACE, "12841062955726\0----------------------------------------------------", 0x33}, + {10, 0x5BADCAFEFACE, "100801993177806\0---------------------------------------------------", 0x33}, + {10, 0xAFACEBEEFCAFE, "3090515640699646\0--------------------------------------------------", 0x33}, + {10, 0xA5BEEFABCDCAFE, "46653307746110206\0-------------------------------------------------", 0x33}, + {10, 0x1F8CF9BF2DF3AF1, "142091656963767025\0------------------------------------------------", 0x33}, + {10, 0xFFFFFFFFFFFFFFF, "1152921504606846975\0-----------------------------------------------", 0x33}, + {10, 0x7FFFFFFFFFFFFFFF, "9223372036854775807\0-----------------------------------------------", 0x33}, + {10, 0x8000000000000000, "-9223372036854775808\0----------------------------------------------", 0x11}, + {10, 0x8000000000000000, "9223372036854775808\0-----------------------------------------------", 0x22}, + {10, 0x8000000000000001, "-9223372036854775807\0----------------------------------------------", 0x55}, + {10, 0x8000000000000001, "-9223372036854775809\0----------------------------------------------", 0x00}, + {10, 0x8000000000000001, "9223372036854775809\0-----------------------------------------------", 0x22}, + {10, 0x8000000000000002, "-9223372036854775806\0----------------------------------------------", 0x55}, + {10, 0x8000000000000002, "-9223372036854775810\0----------------------------------------------", 0x00}, + {10, 0x8000000000000002, "9223372036854775810\0-----------------------------------------------", 0x22}, + {10, 0xFFFFFFFFFFFFFFFE, "-2\0----------------------------------------------------------------", 0x55}, + {10, 0xFFFFFFFFFFFFFFFE, "-18446744073709551614\0---------------------------------------------", 0x00}, + {10, 0xFFFFFFFFFFFFFFFE, "18446744073709551614\0----------------------------------------------", 0x22}, + {10, 0xFFFFFFFFFFFFFFFF, "-1\0----------------------------------------------------------------", 0x55}, + {10, 0xFFFFFFFFFFFFFFFF, "-18446744073709551615\0---------------------------------------------", 0x00}, + {10, 0xFFFFFFFFFFFFFFFF, "18446744073709551615\0----------------------------------------------", 0x22}, + + {16, 0, "0\0-----------------------------------------------------------------", 0x33}, + {16, 1, "1\0-----------------------------------------------------------------", 0x33}, + {16, 2147483646, "7ffffffe\0----------------------------------------------------------", 0x33}, + {16, 2147483647, "7fffffff\0----------------------------------------------------------", 0x33}, + {16, 0x80000000, "80000000\0----------------------------------------------------------", 0x33}, + {16, 0x80000001, "80000001\0----------------------------------------------------------", 0x33}, + {16, 0xFFFFFFFE, "fffffffe\0----------------------------------------------------------", 0x33}, + {16, 0xFFFFFFFF, "ffffffff\0----------------------------------------------------------", 0x33}, + {16, 0x100000000, "100000000\0---------------------------------------------------------", 0x33}, + {16, 0xBADDEADBEEF, "baddeadbeef\0-------------------------------------------------------", 0x33}, + {16, 0x8000000000000000, "8000000000000000\0--------------------------------------------------", 0x33}, + {16, 0xFEDCBA9876543210, "fedcba9876543210\0--------------------------------------------------", 0x33}, + {16, 0xFFFFFFFF80000001, "ffffffff80000001\0--------------------------------------------------", 0x33}, + {16, 0xFFFFFFFFFFFFFFFE, "fffffffffffffffe\0--------------------------------------------------", 0x33}, + {16, 0xFFFFFFFFFFFFFFFF, "ffffffffffffffff\0--------------------------------------------------", 0x33}, + + { 2, 32768, "1000000000000000\0--------------------------------------------------", 0x33}, + { 2, 65536, "10000000000000000\0-------------------------------------------------", 0x33}, + { 2, 131072, "100000000000000000\0------------------------------------------------", 0x33}, + {16, 0xffffffff, "ffffffff\0----------------------------------------------------------", 0x33}, + {16, 0xa, "a\0-----------------------------------------------------------------", 0x33}, + {16, 0, "0\0-----------------------------------------------------------------", 0x33}, + {20, 3368421, "111111\0------------------------------------------------------------", 0x33}, + {36, 62193781, "111111\0------------------------------------------------------------", 0x33}, + {37, 71270178, "111111\0------------------------------------------------------------", 0x33}, + {99, 9606940300, "111111\0------------------------------------------------------------", 0x33}, +}; +#define NB_ULONGLONG2STR (sizeof(ulonglong2str)/sizeof(*ulonglong2str)) + + +static void one_i64toa_test(int test_num, const ulonglong2str_t *ulonglong2str) +{ + LPSTR result; + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_i64toa(ulonglong2str->value, dest_str, ulonglong2str->base); + ok(result == dest_str, + "(test %d): _i64toa(%Lu, [out], %d) has result %p, expected: %p", + test_num, ulonglong2str->value, ulonglong2str->base, result, dest_str); + if (ulonglong2str->mask & 0x04) { + if (memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) { + if (memcmp(dest_str, ulonglong2str[1].Buffer, LARGE_STRI_BUFFER_LENGTH) != 0) { + ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer); + } /* if */ + } /* if */ + } else { + ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _i64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer); + } /* if */ +} + + +static void one_ui64toa_test(int test_num, const ulonglong2str_t *ulonglong2str) +{ + LPSTR result; + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_ui64toa(ulonglong2str->value, dest_str, ulonglong2str->base); + ok(result == dest_str, + "(test %d): _ui64toa(%Lu, [out], %d) has result %p, expected: %p", + test_num, ulonglong2str->value, ulonglong2str->base, result, dest_str); + ok(memcmp(dest_str, ulonglong2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): _ui64toa(%Lu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, dest_str, ulonglong2str->Buffer); +} + + +static void test_ulonglongtoa(void) +{ + int test_num; + + for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) { + if (ulonglong2str[test_num].mask & 0x01) { + one_i64toa_test(test_num, &ulonglong2str[test_num]); + } /* if */ + if (p_ui64toa != NULL) { + if (ulonglong2str[test_num].mask & 0x02) { + one_ui64toa_test(test_num, &ulonglong2str[test_num]); + } /* if */ + } /* if */ + } /* for */ +} + + +static void one_i64tow_test(int test_num, const ulonglong2str_t *ulonglong2str) +{ + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + LPWSTR result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulonglong2str->Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + dest_wstr[pos] = '-'; + } /* for */ + dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR); + unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR); + unicode_string.Buffer = dest_wstr; + + result = p_i64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + ok(result == dest_wstr, + "(test %d): _i64tow(%llu, [out], %d) has result %p, expected: %p", + test_num, ulonglong2str->value, ulonglong2str->base, result, dest_wstr); + if (ulonglong2str->mask & 0x04) { + if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) { + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulonglong2str[1].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + if (memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) != 0) { + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer); + } /* if */ + } /* if */ + } else { + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _i64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer); + } /* if */ + pRtlFreeAnsiString(&ansi_str); +} + + +static void one_ui64tow_test(int test_num, const ulonglong2str_t *ulonglong2str) +{ + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + WCHAR dest_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + LPWSTR result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulonglong2str->Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + dest_wstr[pos] = '-'; + } /* for */ + dest_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + unicode_string.Length = LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR); + unicode_string.MaximumLength = unicode_string.Length + sizeof(WCHAR); + unicode_string.Buffer = dest_wstr; + + result = p_ui64tow(ulonglong2str->value, dest_wstr, ulonglong2str->base); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + ok(result == dest_wstr, + "(test %d): _ui64tow(%llu, [out], %d) has result %p, expected: %p", + test_num, ulonglong2str->value, ulonglong2str->base, result, dest_wstr); + ok(memcmp(dest_wstr, expected_wstr, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): _ui64tow(%llu, [out], %d) assigns string \"%s\", expected: \"%s\"", + test_num, ulonglong2str->value, ulonglong2str->base, ansi_str.Buffer, ulonglong2str->Buffer); + pRtlFreeAnsiString(&ansi_str); +} + + +static void test_ulonglongtow(void) +{ + int test_num; + int pos; + WCHAR expected_wstr[LARGE_STRI_BUFFER_LENGTH + 1]; + LPWSTR result; + + for (test_num = 0; test_num < NB_ULONGLONG2STR; test_num++) { + if (ulonglong2str[test_num].mask & 0x10) { + one_i64tow_test(test_num, &ulonglong2str[test_num]); + } /* if */ + if (p_ui64tow) { + if (ulonglong2str[test_num].mask & 0x20) { + one_ui64tow_test(test_num, &ulonglong2str[test_num]); + } /* if */ + } /* if */ + } /* for */ + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str[0].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_i64tow(ulong2str[0].value, NULL, 10); + ok(result == NULL, + "(test d): _i64tow(%llu, NULL, 10) has result %p, expected: NULL", + ulonglong2str[0].value, result); + + if (p_ui64tow) { + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_wstr[pos] = ulong2str[0].Buffer[pos]; + } /* for */ + expected_wstr[LARGE_STRI_BUFFER_LENGTH] = '\0'; + result = p_ui64tow(ulong2str[0].value, NULL, 10); + ok(result == NULL, + "(test e): _ui64tow(%llu, NULL, 10) has result %p, expected: NULL", + ulonglong2str[0].value, result); + } /* if */ +} + + +typedef struct { + char *str; + LONG value; +} str2long_t; + +static const str2long_t str2long[] = { + { "1011101100", 1011101100 }, + { "1234567", 1234567 }, + { "-214", -214 }, + { "+214", 214 }, /* The + sign is allowed also */ + { "--214", 0 }, /* Do not accept more than one sign */ + { "-+214", 0 }, + { "++214", 0 }, + { "+-214", 0 }, + { "\00141", 0 }, /* not whitespace char 1 */ + { "\00242", 0 }, /* not whitespace char 2 */ + { "\00343", 0 }, /* not whitespace char 3 */ + { "\00444", 0 }, /* not whitespace char 4 */ + { "\00545", 0 }, /* not whitespace char 5 */ + { "\00646", 0 }, /* not whitespace char 6 */ + { "\00747", 0 }, /* not whitespace char 7 */ + { "\01050", 0 }, /* not whitespace char 8 */ + { "\01151", 51 }, /* is whitespace char 9 (tab) */ + { "\01252", 52 }, /* is whitespace char 10 (lf) */ + { "\01353", 53 }, /* is whitespace char 11 (vt) */ + { "\01454", 54 }, /* is whitespace char 12 (ff) */ + { "\01555", 55 }, /* is whitespace char 13 (cr) */ + { "\01656", 0 }, /* not whitespace char 14 */ + { "\01757", 0 }, /* not whitespace char 15 */ + { "\02060", 0 }, /* not whitespace char 16 */ + { "\02161", 0 }, /* not whitespace char 17 */ + { "\02262", 0 }, /* not whitespace char 18 */ + { "\02363", 0 }, /* not whitespace char 19 */ + { "\02464", 0 }, /* not whitespace char 20 */ + { "\02565", 0 }, /* not whitespace char 21 */ + { "\02666", 0 }, /* not whitespace char 22 */ + { "\02767", 0 }, /* not whitespace char 23 */ + { "\03070", 0 }, /* not whitespace char 24 */ + { "\03171", 0 }, /* not whitespace char 25 */ + { "\03272", 0 }, /* not whitespace char 26 */ + { "\03373", 0 }, /* not whitespace char 27 */ + { "\03474", 0 }, /* not whitespace char 28 */ + { "\03575", 0 }, /* not whitespace char 29 */ + { "\03676", 0 }, /* not whitespace char 30 */ + { "\03777", 0 }, /* not whitespace char 31 */ + { "\04080", 80 }, /* is whitespace char 32 (space) */ + { " \n \r \t214", 214 }, + { " \n \r \t+214", 214 }, /* Signs can be used after whitespace */ + { " \n \r \t-214", -214 }, + { "+214 0", 214 }, /* Space terminates the number */ + { " 214.01", 214 }, /* Decimal point not accepted */ + { " 214,01", 214 }, /* Decimal comma not accepted */ + { "f81", 0 }, + { "0x12345", 0 }, /* Hex not accepted */ + { "00x12345", 0 }, + { "0xx12345", 0 }, + { "1x34", 1 }, + { "-9999999999", -1410065407 }, /* Big negative integer */ + { "-2147483649", 2147483647 }, /* Too small to fit in 32 Bits */ + { "-2147483648", 0x80000000 }, /* Smallest negative integer */ + { "-2147483647", -2147483647 }, + { "-1", -1 }, + { "0", 0 }, + { "1", 1 }, + { "2147483646", 2147483646 }, + { "2147483647", 2147483647 }, /* Largest signed positive integer */ + { "2147483648", 2147483648UL }, /* Positive int equal to smallest negative int */ + { "2147483649", 2147483649UL }, + { "4294967294", 4294967294UL }, + { "4294967295", 4294967295UL }, /* Largest unsigned integer */ + { "4294967296", 0 }, /* Too big to fit in 32 Bits */ + { "9999999999", 1410065407 }, /* Big positive integer */ + { "056789", 56789 }, /* Leading zero and still decimal */ + { "b1011101100", 0 }, /* Binary (b-notation) */ + { "-b1011101100", 0 }, /* Negative Binary (b-notation) */ + { "b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */ + { "0b1011101100", 0 }, /* Binary (0b-notation) */ + { "-0b1011101100", 0 }, /* Negative binary (0b-notation) */ + { "0b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */ + { "-0b10123456789", 0 }, /* Negative binary with nonbinary digits (2-9) */ + { "0b1", 0 }, /* one digit binary */ + { "0b2", 0 }, /* empty binary */ + { "0b", 0 }, /* empty binary */ + { "o1234567", 0 }, /* Octal (o-notation) */ + { "-o1234567", 0 }, /* Negative Octal (o-notation) */ + { "o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */ + { "0o1234567", 0 }, /* Octal (0o-notation) */ + { "-0o1234567", 0 }, /* Negative octal (0o-notation) */ + { "0o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */ + { "-0o56789", 0 }, /* Negative octal with nonoctal digits (8 and 9) */ + { "0o7", 0 }, /* one digit octal */ + { "0o8", 0 }, /* empty octal */ + { "0o", 0 }, /* empty octal */ + { "0d1011101100", 0 }, /* explizit decimal with 0d */ + { "x89abcdef", 0 }, /* Hex with lower case digits a-f (x-notation) */ + { "xFEDCBA00", 0 }, /* Hex with upper case digits A-F (x-notation) */ + { "-xFEDCBA00", 0 }, /* Negative Hexadecimal (x-notation) */ + { "0x89abcdef", 0 }, /* Hex with lower case digits a-f (0x-notation) */ + { "0xFEDCBA00", 0 }, /* Hex with upper case digits A-F (0x-notation) */ + { "-0xFEDCBA00", 0 }, /* Negative Hexadecimal (0x-notation) */ + { "0xabcdefgh", 0 }, /* Hex with illegal lower case digits (g-z) */ + { "0xABCDEFGH", 0 }, /* Hex with illegal upper case digits (G-Z) */ + { "0xF", 0 }, /* one digit hexadecimal */ + { "0xG", 0 }, /* empty hexadecimal */ + { "0x", 0 }, /* empty hexadecimal */ + { "", 0 }, /* empty string */ +/* { NULL, 0 }, */ /* NULL as string */ +}; +#define NB_STR2LONG (sizeof(str2long)/sizeof(*str2long)) + + +static void test_wtoi(void) +{ + int test_num; + UNICODE_STRING uni; + int result; + + for (test_num = 0; test_num < NB_STR2LONG; test_num++) { + pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str); + result = p_wtoi(uni.Buffer); + ok(result == str2long[test_num].value, + "(test %d): call failed: _wtoi(\"%s\") has result %d, expected: %ld", + test_num, str2long[test_num].str, result, str2long[test_num].value); + pRtlFreeUnicodeString(&uni); + } /* for */ +} + + +static void test_wtol(void) +{ + int test_num; + UNICODE_STRING uni; + LONG result; + + for (test_num = 0; test_num < NB_STR2LONG; test_num++) { + pRtlCreateUnicodeStringFromAsciiz(&uni, str2long[test_num].str); + result = p_wtol(uni.Buffer); + ok(result == str2long[test_num].value, + "(test %d): call failed: _wtol(\"%s\") has result %ld, expected: %ld", + test_num, str2long[test_num].str, result, str2long[test_num].value); + pRtlFreeUnicodeString(&uni); + } /* for */ +} + + +typedef struct { + char *str; + LONGLONG value; +} str2longlong_t; + +static const str2longlong_t str2longlong[] = { + { "1011101100", 1011101100 }, + { "1234567", 1234567 }, + { "-214", -214 }, + { "+214", 214 }, /* The + sign is allowed also */ + { "--214", 0 }, /* Do not accept more than one sign */ + { "-+214", 0 }, + { "++214", 0 }, + { "+-214", 0 }, + { "\00141", 0 }, /* not whitespace char 1 */ + { "\00242", 0 }, /* not whitespace char 2 */ + { "\00343", 0 }, /* not whitespace char 3 */ + { "\00444", 0 }, /* not whitespace char 4 */ + { "\00545", 0 }, /* not whitespace char 5 */ + { "\00646", 0 }, /* not whitespace char 6 */ + { "\00747", 0 }, /* not whitespace char 7 */ + { "\01050", 0 }, /* not whitespace char 8 */ + { "\01151", 51 }, /* is whitespace char 9 (tab) */ + { "\01252", 52 }, /* is whitespace char 10 (lf) */ + { "\01353", 53 }, /* is whitespace char 11 (vt) */ + { "\01454", 54 }, /* is whitespace char 12 (ff) */ + { "\01555", 55 }, /* is whitespace char 13 (cr) */ + { "\01656", 0 }, /* not whitespace char 14 */ + { "\01757", 0 }, /* not whitespace char 15 */ + { "\02060", 0 }, /* not whitespace char 16 */ + { "\02161", 0 }, /* not whitespace char 17 */ + { "\02262", 0 }, /* not whitespace char 18 */ + { "\02363", 0 }, /* not whitespace char 19 */ + { "\02464", 0 }, /* not whitespace char 20 */ + { "\02565", 0 }, /* not whitespace char 21 */ + { "\02666", 0 }, /* not whitespace char 22 */ + { "\02767", 0 }, /* not whitespace char 23 */ + { "\03070", 0 }, /* not whitespace char 24 */ + { "\03171", 0 }, /* not whitespace char 25 */ + { "\03272", 0 }, /* not whitespace char 26 */ + { "\03373", 0 }, /* not whitespace char 27 */ + { "\03474", 0 }, /* not whitespace char 28 */ + { "\03575", 0 }, /* not whitespace char 29 */ + { "\03676", 0 }, /* not whitespace char 30 */ + { "\03777", 0 }, /* not whitespace char 31 */ + { "\04080", 80 }, /* is whitespace char 32 (space) */ + { " \n \r \t214", 214 }, + { " \n \r \t+214", 214 }, /* Signs can be used after whitespace */ + { " \n \r \t-214", -214 }, + { "+214 0", 214 }, /* Space terminates the number */ + { " 214.01", 214 }, /* Decimal point not accepted */ + { " 214,01", 214 }, /* Decimal comma not accepted */ + { "f81", 0 }, + { "0x12345", 0 }, /* Hex not accepted */ + { "00x12345", 0 }, + { "0xx12345", 0 }, + { "1x34", 1 }, + { "-99999999999999999999", -7766279631452241919 }, /* Big negative integer */ + { "-9223372036854775809", 9223372036854775807 }, /* Too small to fit in 64 bits */ + { "-9223372036854775808", 0x8000000000000000 }, /* Smallest negativ 64 bit integer */ + { "-9223372036854775807", -9223372036854775807 }, + { "-9999999999", -9999999999 }, + { "-2147483649", -2147483649LL }, /* Too small to fit in 32 bits */ + { "-2147483648", -2147483648LL }, /* Smallest 32 bits negative integer */ + { "-2147483647", -2147483647 }, + { "-1", -1 }, + { "0", 0 }, + { "1", 1 }, + { "2147483646", 2147483646 }, + { "2147483647", 2147483647 }, /* Largest signed positive 32 bit integer */ + { "2147483648", 2147483648LL }, /* Pos int equal to smallest neg 32 bit int */ + { "2147483649", 2147483649LL }, + { "4294967294", 4294967294LL }, + { "4294967295", 4294967295LL }, /* Largest unsigned 32 bit integer */ + { "4294967296", 4294967296 }, /* Too big to fit in 32 Bits */ + { "9999999999", 9999999999 }, + { "9223372036854775806", 9223372036854775806 }, + { "9223372036854775807", 9223372036854775807 }, /* Largest signed positive 64 bit integer */ + { "9223372036854775808", 9223372036854775808ULL}, /* Pos int equal to smallest neg 64 bit int */ + { "9223372036854775809", 9223372036854775809ULL}, + { "18446744073709551614", 18446744073709551614ULL}, + { "18446744073709551615", 18446744073709551615ULL}, /* Largest unsigned 64 bit integer */ + { "18446744073709551616", 0 }, /* Too big to fit in 64 bits */ + { "99999999999999999999", 7766279631452241919 }, /* Big positive integer */ + { "056789", 56789 }, /* Leading zero and still decimal */ + { "b1011101100", 0 }, /* Binary (b-notation) */ + { "-b1011101100", 0 }, /* Negative Binary (b-notation) */ + { "b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */ + { "0b1011101100", 0 }, /* Binary (0b-notation) */ + { "-0b1011101100", 0 }, /* Negative binary (0b-notation) */ + { "0b10123456789", 0 }, /* Binary with nonbinary digits (2-9) */ + { "-0b10123456789", 0 }, /* Negative binary with nonbinary digits (2-9) */ + { "0b1", 0 }, /* one digit binary */ + { "0b2", 0 }, /* empty binary */ + { "0b", 0 }, /* empty binary */ + { "o1234567", 0 }, /* Octal (o-notation) */ + { "-o1234567", 0 }, /* Negative Octal (o-notation) */ + { "o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */ + { "0o1234567", 0 }, /* Octal (0o-notation) */ + { "-0o1234567", 0 }, /* Negative octal (0o-notation) */ + { "0o56789", 0 }, /* Octal with nonoctal digits (8 and 9) */ + { "-0o56789", 0 }, /* Negative octal with nonoctal digits (8 and 9) */ + { "0o7", 0 }, /* one digit octal */ + { "0o8", 0 }, /* empty octal */ + { "0o", 0 }, /* empty octal */ + { "0d1011101100", 0 }, /* explizit decimal with 0d */ + { "x89abcdef", 0 }, /* Hex with lower case digits a-f (x-notation) */ + { "xFEDCBA00", 0 }, /* Hex with upper case digits A-F (x-notation) */ + { "-xFEDCBA00", 0 }, /* Negative Hexadecimal (x-notation) */ + { "0x89abcdef", 0 }, /* Hex with lower case digits a-f (0x-notation) */ + { "0xFEDCBA00", 0 }, /* Hex with upper case digits A-F (0x-notation) */ + { "-0xFEDCBA00", 0 }, /* Negative Hexadecimal (0x-notation) */ + { "0xabcdefgh", 0 }, /* Hex with illegal lower case digits (g-z) */ + { "0xABCDEFGH", 0 }, /* Hex with illegal upper case digits (G-Z) */ + { "0xF", 0 }, /* one digit hexadecimal */ + { "0xG", 0 }, /* empty hexadecimal */ + { "0x", 0 }, /* empty hexadecimal */ + { "", 0 }, /* empty string */ +/* { NULL, 0 }, */ /* NULL as string */ +}; +#define NB_STR2LONGLONG (sizeof(str2longlong)/sizeof(*str2longlong)) + + +static void test_atoi64(void) +{ + int test_num; + LONGLONG result; + + for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) { + result = p_atoi64(str2longlong[test_num].str); + ok(result == str2longlong[test_num].value, + "(test %d): call failed: _atoi64(\"%s\") has result %lld, expected: %lld", + test_num, str2longlong[test_num].str, result, str2longlong[test_num].value); + } /* for */ +} + + +static void test_wtoi64(void) +{ + int test_num; + UNICODE_STRING uni; + LONGLONG result; + + for (test_num = 0; test_num < NB_STR2LONGLONG; test_num++) { + pRtlCreateUnicodeStringFromAsciiz(&uni, str2longlong[test_num].str); + result = p_wtoi64(uni.Buffer); + ok(result == str2longlong[test_num].value, + "(test %d): call failed: _wtoi64(\"%s\") has result %lld, expected: %lld", + test_num, str2longlong[test_num].str, result, str2longlong[test_num].value); + pRtlFreeUnicodeString(&uni); + } /* for */ +} + + +START_TEST(string) +{ + InitFunctionPtrs(); + + test_ulongtoa(); + test_ulonglongtoa(); + test_atoi64(); + + test_ulongtow(); + test_ulonglongtow(); + test_wtoi(); + test_wtol(); + test_wtoi64(); +}