some ntdll functions (2b) - part 2: tests

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hello

Here are the tests for some ntdll functions.
This time the tests are in just one file.

These tests require the functions implemented in
part 1 of this patch (see part1: functions).

Changelog:

    * dlls/ntdll/tests/Makefile.in,
      dlls/ntdll/tests/string.c:
    Thomas Mertes <thomas.mertes@gmx.at>
    - Tests for _itoa, _ltoa, _ultoa, _i64toa,
      _ui64toa, _itow, _ltow, _ultow, _i64tow,
      _ui64tow, _atoi64, _wtoi, _wtol, _wtoi64

Greetings
Thomas Mertes

-- 
+++ GMX - Mail, Messaging & more  http://www.gmx.net +++
Bitte lächeln! Fotogalerie online mit GMX ohne eigene Homepage!
diff -urN old_wine-20030219/dlls/ntdll/tests/Makefile.in new_wine-20030219/dlls/ntdll/tests/Makefile.in
--- old_wine-20030219/dlls/ntdll/tests/Makefile.in	Wed Feb 19 04:40:14 2003
+++ new_wine-20030219/dlls/ntdll/tests/Makefile.in	Tue Mar 18 01:27:56 2003
@@ -10,7 +10,8 @@
 	generated.c \
 	large_int.c \
 	rtlbitmap.c \
-	rtlstr.c
+	rtlstr.c \
+	string.c
 
 @MAKE_TEST_RULES@
 
diff -urN old_wine-20030219/dlls/ntdll/tests/string.c new_wine-20030219/dlls/ntdll/tests/string.c
--- old_wine-20030219/dlls/ntdll/tests/string.c	Thu Jan  1 01:00:00 1970
+++ new_wine-20030219/dlls/ntdll/tests/string.c	Tue Mar 18 01:25:58 2003
@@ -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 <stdlib.h>
+
+#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();
+}

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux