From 9f5f86e3a383cfe232c424d22d02e4f813dd9043 Mon Sep 17 00:00:00 2001 From: Thomas Mertes Date: Wed, 19 Feb 2003 03:40:14 +0000 Subject: [PATCH] Tests for RtlCharToInteger, RtlExtendedMagicDivide, RtlUpperChar, RtlInt64ToUnicodeString, RtlIntegerToChar, RtlIntegerToUnicodeString, RtlLargeIntegerToChar, RtlUnicodeStringToInteger and RtlUpcaseUnicodeChar. --- dlls/ntdll/tests/.cvsignore | 1 + dlls/ntdll/tests/Makefile.in | 1 + dlls/ntdll/tests/large_int.c | 424 ++++++++++++++++++++ dlls/ntdll/tests/rtlstr.c | 730 +++++++++++++++++++++++++++++++---- 4 files changed, 1076 insertions(+), 80 deletions(-) create mode 100644 dlls/ntdll/tests/large_int.c diff --git a/dlls/ntdll/tests/.cvsignore b/dlls/ntdll/tests/.cvsignore index 2d972b0e969..f5f16015d70 100644 --- a/dlls/ntdll/tests/.cvsignore +++ b/dlls/ntdll/tests/.cvsignore @@ -1,6 +1,7 @@ Makefile error.ok generated.ok +large_int.ok ntdll_test.exe.spec.c rtlbitmap.ok rtlstr.ok diff --git a/dlls/ntdll/tests/Makefile.in b/dlls/ntdll/tests/Makefile.in index 252f012c2ff..64ee289d7d8 100644 --- a/dlls/ntdll/tests/Makefile.in +++ b/dlls/ntdll/tests/Makefile.in @@ -8,6 +8,7 @@ IMPORTS = ntdll CTESTS = \ error.c \ generated.c \ + large_int.c \ rtlbitmap.c \ rtlstr.c diff --git a/dlls/ntdll/tests/large_int.c b/dlls/ntdll/tests/large_int.c new file mode 100644 index 00000000000..a2d6cdc6caf --- /dev/null +++ b/dlls/ntdll/tests/large_int.c @@ -0,0 +1,424 @@ +/* Unit test suite for Rtl large integer 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 LONGLONG (WINAPI *pRtlExtendedMagicDivide)(LONGLONG, LONGLONG, INT); +static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING); +static NTSTATUS (WINAPI *pRtlInt64ToUnicodeString)(ULONGLONG, ULONG, UNICODE_STRING *); +static NTSTATUS (WINAPI *pRtlLargeIntegerToChar)(ULONGLONG *, ULONG, ULONG, PCHAR); +static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN); + + +static void InitFunctionPtrs() +{ + hntdll = LoadLibraryA("ntdll.dll"); + ok(hntdll != 0, "LoadLibrary failed"); + if (hntdll) { + pRtlExtendedMagicDivide = (void *)GetProcAddress(hntdll, "RtlExtendedMagicDivide"); + pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString"); + pRtlInt64ToUnicodeString = (void *)GetProcAddress(hntdll, "RtlInt64ToUnicodeString"); + pRtlLargeIntegerToChar = (void *)GetProcAddress(hntdll, "RtlLargeIntegerToChar"); + pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString"); + } /* if */ +} + + +typedef struct { + LONGLONG a; + LONGLONG b; + INT shift; + LONGLONG result; +} magic_divide_t; + +static const magic_divide_t magic_divide[] = { + { 3, 0x5555555555555555U, 0, 0}, /* 1 */ + { 333333333, 0x5555555555555555U, 0, 111111110}, /* 111111111 */ + { 0x7fffffffffffffff, 0x5555555555555555U, 0, 0x2aaaaaaaaaaaaaaa}, + { 3, 0xaaaaaaaaaaaaaaaaU, 1, 0}, /* 1 */ + { 333333333, 0xaaaaaaaaaaaaaaaaU, 1, 111111110}, /* 111111111 */ + { 0x7fffffffffffffff, 0xaaaaaaaaaaaaaaaaU, 1, 0x2aaaaaaaaaaaaaaa}, + { -3, 0x5555555555555555U, 0, 0}, /* -1 */ + { -333333333, 0x5555555555555555U, 0, -111111110}, /* -111111111 */ + {-0x7fffffffffffffff, 0x5555555555555555U, 0, -0x2aaaaaaaaaaaaaaa}, + { -3, 0xaaaaaaaaaaaaaaaaU, 1, 0}, /* -1 */ + { -333333333, 0xaaaaaaaaaaaaaaaaU, 1, -111111110}, /* -111111111 */ + {-0x7fffffffffffffff, 0xaaaaaaaaaaaaaaaaU, 1, -0x2aaaaaaaaaaaaaaa}, + { -3, -0x5555555555555555U, 0, -2}, /* -1 */ + { -333333333, -0x5555555555555555U, 0, -222222222}, /* -111111111 */ + {-0x7fffffffffffffff, -0x5555555555555555U, 0, -0x5555555555555554}, + { -3, -0xaaaaaaaaaaaaaaaaU, 1, 0}, /* -1 */ + { -333333333, -0xaaaaaaaaaaaaaaaaU, 1, -55555555}, /* -111111111 */ + {-0x7fffffffffffffff, -0xaaaaaaaaaaaaaaaaU, 1, -0x1555555555555555}, + { 3, -0x5555555555555555U, 0, 2}, /* -1 */ + { 333333333, -0x5555555555555555U, 0, 222222222}, /* -111111111 */ + { 0x7fffffffffffffff, -0x5555555555555555U, 0, 0x5555555555555554}, + { 3, -0xaaaaaaaaaaaaaaaaU, 1, 0}, /* -1 */ + { 333333333, -0xaaaaaaaaaaaaaaaaU, 1, 55555555}, /* -111111111 */ + { 0x7fffffffffffffff, -0xaaaaaaaaaaaaaaaaU, 1, 0x1555555555555555}, + { 3, 12297829382473033728U, 1, 0}, /* 1 */ + { 333333333, 12297829382473033728U, 1, 111111110}, /* 111111111 */ + { 0x7fffffffffffffff, 12297829382473033728U, 1, 0x2aaaaaaaaaaaa9ff}, /* 0x2aaaaaaaaaaaaaaa */ + { 5, 3689348814741910527U, 0, 1}, + { 555555555, 3689348814741910527U, 0, 111111111}, + { 0x7fffffffffffffff, 3689348814741910527U, 0, 0x19999999999999ff}, /* 0x199999999999999a */ + { 5, 7378697629483821054U, 1, 1}, + { 555555555, 7378697629483821054U, 1, 111111111}, + { 0x7fffffffffffffff, 7378697629483821054U, 1, 0x19999999999999ff}, /* 0x199999999999999a */ + { 5, 14757395258967642109U, 2, 1}, + { 555555555, 14757395258967642109U, 2, 111111111}, + { 0x7fffffffffffffff, 14757395258967642109U, 2, 0x19999999999999ff}, /* 0x199999999999999a */ + { 0xaddcafeface, 0x2f1e28fd1b5ccaU, 33, 1}, + { 0x81ac1b9c2310a80, 0x2f1e28fd1b5ccaU, 33, 0xbeef}, + { 0x74ae3b5f1558c800, 0x2f1e28fd1b5ccaU, 33, 0xabcde}, + { 0xaddcafeface, 0x2f1e28fd1b5cca00U, 41, 1}, + { 0x81ac1b9c2310a80, 0x2f1e28fd1b5cca00U, 41, 0xbeef}, + { 0x74ae3b5f1558c800, 0x2f1e28fd1b5cca00U, 41, 0xabcde}, + +}; +#define NB_MAGIC_DIVIDE (sizeof(magic_divide)/sizeof(*magic_divide)) + + +static void test_RtlExtendedMagicDivide(void) +{ + int i; + LONGLONG result; + + for (i = 0; i < NB_MAGIC_DIVIDE; i++) { + result = pRtlExtendedMagicDivide(magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift); + ok(result == magic_divide[i].result, + "call failed: RtlExtendedMagicDivide(%lld, %llu, %d) has result %llx, expected %llx", + magic_divide[i].a, magic_divide[i].b, magic_divide[i].shift, result, magic_divide[i].result); + } +} + + +#define LARGE_STRI_BUFFER_LENGTH 67 + +typedef struct { + int base; + ULONGLONG value; + USHORT Length; + USHORT MaximumLength; + char *Buffer; + NTSTATUS result; +} largeint2str_t; + +/* + * The native DLL does produce garbage or STATUS_BUFFER_OVERFLOW for + * base 2, 8 and 16 when the value is larger than 0xFFFFFFFF. + * Therefore these testcases are commented out. + */ + +static const largeint2str_t largeint2str[] = { + {10, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS}, + + { 0, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS}, + { 0, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS}, + { 0, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS}, + { 0, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 12, 2, 11, "12\0----------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 123, 3, 11, "123\0---------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 1234, 4, 11, "1234\0--------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 12345, 5, 11, "12345\0-------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 123456, 6, 11, "123456\0------------------------------------------------------------", STATUS_SUCCESS}, + { 0, 1234567, 7, 11, "1234567\0-----------------------------------------------------------", STATUS_SUCCESS}, + { 0, 12345678, 8, 11, "12345678\0----------------------------------------------------------", STATUS_SUCCESS}, + { 0, 123456789, 9, 11, "123456789\0---------------------------------------------------------", STATUS_SUCCESS}, + { 0, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS}, + { 0, 12345678901U, 11, 12, "12345678901\0-------------------------------------------------------", STATUS_SUCCESS}, + { 0, 987654321012U, 12, 13, "987654321012\0------------------------------------------------------", STATUS_SUCCESS}, + { 0, 1928374656574U, 13, 14, "1928374656574\0-----------------------------------------------------", STATUS_SUCCESS}, + { 0, 0xBADCAFEFACE, 14, 15, "12841062955726\0----------------------------------------------------", STATUS_SUCCESS}, + { 0, 0x5BADCAFEFACE, 15, 16, "100801993177806\0---------------------------------------------------", STATUS_SUCCESS}, + { 0, 0xAFACEBEEFCAFE, 16, 20, "3090515640699646\0--------------------------------------------------", STATUS_SUCCESS}, + { 0, 0xA5BEEFABCDCAFE, 17, 20, "46653307746110206\0-------------------------------------------------", STATUS_SUCCESS}, + { 0, 0x1F8CF9BF2DF3AF1, 18, 20, "142091656963767025\0------------------------------------------------", STATUS_SUCCESS}, + { 0, 0xFFFFFFFFFFFFFFF, 19, 20, "1152921504606846975\0-----------------------------------------------", STATUS_SUCCESS}, + { 0, 0xFFFFFFFFFFFFFFFE, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS}, + { 0, 0xFFFFFFFFFFFFFFFF, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS}, + + { 2, 0x80000000U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS}, +/* + * { 2, -2147483647, 64, 65, "1111111111111111111111111111111110000000000000000000000000000001\0--", STATUS_SUCCESS}, + * { 2, -2, 64, 65, "1111111111111111111111111111111111111111111111111111111111111110\0--", STATUS_SUCCESS}, + * { 2, -1, 64, 65, "1111111111111111111111111111111111111111111111111111111111111111\0--", STATUS_SUCCESS}, + */ + { 2, 0, 1, 33, "0\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 2, 1, 1, 33, "1\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 2, 10, 4, 33, "1010\0--------------------------------------------------------------", STATUS_SUCCESS}, + { 2, 100, 7, 33, "1100100\0-----------------------------------------------------------", STATUS_SUCCESS}, + { 2, 1000, 10, 33, "1111101000\0--------------------------------------------------------", STATUS_SUCCESS}, + { 2, 10000, 14, 33, "10011100010000\0----------------------------------------------------", STATUS_SUCCESS}, + { 2, 32767, 15, 33, "111111111111111\0---------------------------------------------------", STATUS_SUCCESS}, + { 2, 32768, 16, 33, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS}, + { 2, 65535, 16, 33, "1111111111111111\0--------------------------------------------------", STATUS_SUCCESS}, + { 2, 100000, 17, 33, "11000011010100000\0-------------------------------------------------", STATUS_SUCCESS}, + { 2, 1000000, 20, 33, "11110100001001000000\0----------------------------------------------", STATUS_SUCCESS}, + { 2, 10000000, 24, 33, "100110001001011010000000\0------------------------------------------", STATUS_SUCCESS}, + { 2, 100000000, 27, 33, "101111101011110000100000000\0---------------------------------------", STATUS_SUCCESS}, + { 2, 1000000000, 30, 33, "111011100110101100101000000000\0------------------------------------", STATUS_SUCCESS}, + { 2, 1073741823, 30, 33, "111111111111111111111111111111\0------------------------------------", STATUS_SUCCESS}, + { 2, 2147483646, 31, 33, "1111111111111111111111111111110\0-----------------------------------", STATUS_SUCCESS}, + { 2, 2147483647, 31, 33, "1111111111111111111111111111111\0-----------------------------------", STATUS_SUCCESS}, + { 2, 2147483648U, 32, 33, "10000000000000000000000000000000\0----------------------------------", STATUS_SUCCESS}, + { 2, 2147483649U, 32, 33, "10000000000000000000000000000001\0----------------------------------", STATUS_SUCCESS}, + { 2, 4294967294U, 32, 33, "11111111111111111111111111111110\0----------------------------------", STATUS_SUCCESS}, + { 2, 0xFFFFFFFF, 32, 33, "11111111111111111111111111111111\0----------------------------------", STATUS_SUCCESS}, +/* + * { 2, 0x1FFFFFFFF, 33, 34, "111111111111111111111111111111111\0---------------------------------", STATUS_SUCCESS}, + * { 2, 0x3FFFFFFFF, 34, 35, "1111111111111111111111111111111111\0--------------------------------", STATUS_SUCCESS}, + * { 2, 0x7FFFFFFFF, 35, 36, "11111111111111111111111111111111111\0-------------------------------", STATUS_SUCCESS}, + * { 2, 0xFFFFFFFFF, 36, 37, "111111111111111111111111111111111111\0------------------------------", STATUS_SUCCESS}, + * { 2, 0x1FFFFFFFFF, 37, 38, "1111111111111111111111111111111111111\0-----------------------------", STATUS_SUCCESS}, + * { 2, 0x3FFFFFFFFF, 38, 39, "11111111111111111111111111111111111111\0----------------------------", STATUS_SUCCESS}, + * { 2, 0x7FFFFFFFFF, 39, 40, "111111111111111111111111111111111111111\0---------------------------", STATUS_SUCCESS}, + * { 2, 0xFFFFFFFFFF, 40, 41, "1111111111111111111111111111111111111111\0--------------------------", STATUS_SUCCESS}, + */ + + { 8, 0x80000000U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS}, +/* + * { 8, -2147483647, 22, 23, "1777777777760000000001\0--------------------------------------------", STATUS_SUCCESS}, + * { 8, -2, 22, 23, "1777777777777777777776\0--------------------------------------------", STATUS_SUCCESS}, + * { 8, -1, 22, 23, "1777777777777777777777\0--------------------------------------------", STATUS_SUCCESS}, + */ + { 8, 0, 1, 12, "0\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 8, 1, 1, 12, "1\0-----------------------------------------------------------------", STATUS_SUCCESS}, + { 8, 2147483646, 11, 12, "17777777776\0-------------------------------------------------------", STATUS_SUCCESS}, + { 8, 2147483647, 11, 12, "17777777777\0-------------------------------------------------------", STATUS_SUCCESS}, + { 8, 2147483648U, 11, 12, "20000000000\0-------------------------------------------------------", STATUS_SUCCESS}, + { 8, 2147483649U, 11, 12, "20000000001\0-------------------------------------------------------", STATUS_SUCCESS}, + { 8, 4294967294U, 11, 12, "37777777776\0-------------------------------------------------------", STATUS_SUCCESS}, + { 8, 4294967295U, 11, 12, "37777777777\0-------------------------------------------------------", STATUS_SUCCESS}, + + {10, 0x80000000U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, -2147483647, 20, 21, "18446744071562067969\0----------------------------------------------", STATUS_SUCCESS}, + {10, -2, 20, 21, "18446744073709551614\0----------------------------------------------", STATUS_SUCCESS}, + {10, -1, 20, 21, "18446744073709551615\0----------------------------------------------", STATUS_SUCCESS}, + {10, 0, 1, 11, "0\0-----------------------------------------------------------------", STATUS_SUCCESS}, + {10, 1, 1, 11, "1\0-----------------------------------------------------------------", STATUS_SUCCESS}, + {10, 2147483646, 10, 11, "2147483646\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, 2147483647, 10, 11, "2147483647\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, 2147483648U, 10, 11, "2147483648\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, 2147483649U, 10, 11, "2147483649\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, 4294967294U, 10, 11, "4294967294\0--------------------------------------------------------", STATUS_SUCCESS}, + {10, 4294967295U, 10, 11, "4294967295\0--------------------------------------------------------", STATUS_SUCCESS}, + + {16, 0, 1, 9, "0\0-----------------------------------------------------------------", STATUS_SUCCESS}, + {16, 1, 1, 9, "1\0-----------------------------------------------------------------", STATUS_SUCCESS}, + {16, 2147483646, 8, 9, "7FFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 2147483647, 8, 9, "7FFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0x80000000, 8, 9, "80000000\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0x80000001, 8, 9, "80000001\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0xFFFFFFFE, 8, 9, "FFFFFFFE\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0xFFFFFFFF, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS}, +/* + * {16, 0x100000000, 9, 10, "100000000\0---------------------------------------------------------", STATUS_SUCCESS}, + * {16, 0xBADDEADBEEF, 11, 12, "BADDEADBEEF\0-------------------------------------------------------", STATUS_SUCCESS}, + * {16, 0x8000000000000000, 16, 17, "8000000000000000\0--------------------------------------------------", STATUS_SUCCESS}, + * {16, 0xFEDCBA9876543210, 16, 17, "FEDCBA9876543210\0--------------------------------------------------", STATUS_SUCCESS}, + * {16, 0xFFFFFFFF80000001, 16, 17, "FFFFFFFF80000001\0--------------------------------------------------", STATUS_SUCCESS}, + * {16, 0xFFFFFFFFFFFFFFFE, 16, 17, "FFFFFFFFFFFFFFFE\0--------------------------------------------------", STATUS_SUCCESS}, + * {16, 0xFFFFFFFFFFFFFFFF, 16, 17, "FFFFFFFFFFFFFFFF\0--------------------------------------------------", STATUS_SUCCESS}, + */ + + { 2, 32768, 16, 17, "1000000000000000\0--------------------------------------------------", STATUS_SUCCESS}, + { 2, 32768, 16, 16, "1000000000000000---------------------------------------------------", STATUS_SUCCESS}, + { 2, 65536, 17, 18, "10000000000000000\0-------------------------------------------------", STATUS_SUCCESS}, + { 2, 65536, 17, 17, "10000000000000000--------------------------------------------------", STATUS_SUCCESS}, + { 2, 131072, 18, 19, "100000000000000000\0------------------------------------------------", STATUS_SUCCESS}, + { 2, 131072, 18, 18, "100000000000000000-------------------------------------------------", STATUS_SUCCESS}, + {16, 0xffffffff, 8, 9, "FFFFFFFF\0----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0xffffffff, 8, 8, "FFFFFFFF-----------------------------------------------------------", STATUS_SUCCESS}, + {16, 0xffffffff, 8, 7, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW}, + {16, 0xa, 1, 2, "A\0-----------------------------------------------------------------", STATUS_SUCCESS}, + {16, 0xa, 1, 1, "A------------------------------------------------------------------", STATUS_SUCCESS}, + {16, 0, 1, 0, "-------------------------------------------------------------------", STATUS_BUFFER_OVERFLOW}, + {20, 0xdeadbeef, 0, 9, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER}, + {-8, 07654321, 0, 12, "-------------------------------------------------------------------", STATUS_INVALID_PARAMETER}, +}; +#define NB_LARGEINT2STR (sizeof(largeint2str)/sizeof(*largeint2str)) + + +static void one_RtlInt64ToUnicodeString_test(int test_num, const largeint2str_t *largeint2str) +{ + int pos; + WCHAR expected_str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING expected_unicode_string; + STRING expected_ansi_str; + WCHAR str_Buffer[LARGE_STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + NTSTATUS result; + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_str_Buffer[pos] = largeint2str->Buffer[pos]; + } /* for */ + expected_unicode_string.Length = largeint2str->Length * sizeof(WCHAR); + expected_unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR); + expected_unicode_string.Buffer = expected_str_Buffer; + pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1); + + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + str_Buffer[pos] = '-'; + } /* for */ + unicode_string.Length = 0; + unicode_string.MaximumLength = largeint2str->MaximumLength * sizeof(WCHAR); + unicode_string.Buffer = str_Buffer; + + if (largeint2str->base == 0) { + result = pRtlInt64ToUnicodeString(largeint2str->value, 10, &unicode_string); + } else { + result = pRtlInt64ToUnicodeString(largeint2str->value, largeint2str->base, &unicode_string); + } /* if */ + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + if (result == STATUS_BUFFER_OVERFLOW) { + /* On BUFFER_OVERFLOW the string Buffer should be unchanged */ + for (pos = 0; pos < LARGE_STRI_BUFFER_LENGTH; pos++) { + expected_str_Buffer[pos] = '-'; + } /* for */ + /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */ + /* If the value is too large to convert: The Length is unchanged */ + /* If str is too small to hold the string: Set str->Length to the length */ + /* the string would have (which can be larger than the MaximumLength). */ + /* To allow all this in the tests we do the following: */ + if (expected_unicode_string.Length >= 64) { + /* The value is too large to convert only triggerd when testing native */ + /* Length is not filled with the expected string length (garbage?) */ + expected_unicode_string.Length = unicode_string.Length; + } /* if */ + } else { + ok(result == largeint2str->result, + "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) has result %lx, expected: %lx", + test_num, largeint2str->value, largeint2str->base, result, largeint2str->result); + if (result == STATUS_SUCCESS) { + ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0', + "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string \"%s\" is not NULL terminated", + test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer); + } /* if */ + } /* if */ + ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, LARGE_STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) assigns string \"%s\", expected: \"%s\"", + test_num, largeint2str->value, largeint2str->base, ansi_str.Buffer, expected_ansi_str.Buffer); + ok(unicode_string.Length == expected_unicode_string.Length, + "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has Length %d, expected: %d", + test_num, largeint2str->value, largeint2str->base, unicode_string.Length, expected_unicode_string.Length); + ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength, + "(test %d): RtlInt64ToUnicodeString(%llu, %d, [out]) string has MaximumLength %d, expected: %d", + test_num, largeint2str->value, largeint2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength); + pRtlFreeAnsiString(&expected_ansi_str); + pRtlFreeAnsiString(&ansi_str); +} + + +static void test_RtlInt64ToUnicodeString(void) +{ + int test_num; + + for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) { + one_RtlInt64ToUnicodeString_test(test_num, &largeint2str[test_num]); + } /* for */ +} + + +static void one_RtlLargeIntegerToChar_test(int test_num, const largeint2str_t *largeint2str) +{ + NTSTATUS result; + char dest_str[LARGE_STRI_BUFFER_LENGTH + 1]; + ULONGLONG value; + + memset(dest_str, '-', LARGE_STRI_BUFFER_LENGTH); + dest_str[LARGE_STRI_BUFFER_LENGTH] = '\0'; + value = largeint2str->value; + if (largeint2str->base == 0) { + result = pRtlLargeIntegerToChar(&value, 10, largeint2str->MaximumLength, dest_str); + } else { + result = pRtlLargeIntegerToChar(&value, largeint2str->base, largeint2str->MaximumLength, dest_str); + } /* if */ + ok(result == largeint2str->result, + "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) has result %lx, expected: %lx", + test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, result, largeint2str->result); + ok(memcmp(dest_str, largeint2str->Buffer, LARGE_STRI_BUFFER_LENGTH) == 0, + "(test %d): RtlLargeIntegerToChar(%llu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"", + test_num, largeint2str->value, largeint2str->base, largeint2str->MaximumLength, dest_str, largeint2str->Buffer); +} + + +static void test_RtlLargeIntegerToChar(void) +{ + NTSTATUS result; + int test_num; + ULONGLONG value; + + for (test_num = 0; test_num < NB_LARGEINT2STR; test_num++) { + one_RtlLargeIntegerToChar_test(test_num, &largeint2str[test_num]); + } /* for */ + + value = largeint2str[0].value; + result = pRtlLargeIntegerToChar(&value, 20, largeint2str[0].MaximumLength, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "(test a): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x", + largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER); + + result = pRtlLargeIntegerToChar(&value, 20, 0, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "(test b): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x", + largeint2str[0].value, 20, largeint2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER); + + result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, 0, NULL); + ok(result == STATUS_BUFFER_OVERFLOW, + "(test c): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x", + largeint2str[0].value, largeint2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW); + + result = pRtlLargeIntegerToChar(&value, largeint2str[0].base, largeint2str[0].MaximumLength, NULL); + ok(result == STATUS_ACCESS_VIOLATION, + "(test d): RtlLargeIntegerToChar(%llu, %d, %d, NULL) has result %lx, expected: %x", + largeint2str[0].value, largeint2str[0].base, largeint2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION); +} + + +START_TEST(large_int) +{ + InitFunctionPtrs(); + + test_RtlExtendedMagicDivide(); + if (pRtlInt64ToUnicodeString != NULL) { + test_RtlInt64ToUnicodeString(); + } /* if */ + test_RtlLargeIntegerToChar(); +} diff --git a/dlls/ntdll/tests/rtlstr.c b/dlls/ntdll/tests/rtlstr.c index 88e9afc5a8d..50e828b5820 100644 --- a/dlls/ntdll/tests/rtlstr.c +++ b/dlls/ntdll/tests/rtlstr.c @@ -1,6 +1,7 @@ /* Unit test suite for Rtl string functions * * Copyright 2002 Robert Shearman + * 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 @@ -34,13 +35,24 @@ static STRING str; /* Function ptrs for ntdll calls */ static HMODULE hntdll = 0; -static VOID (WINAPI *pRtlInitAnsiString)(PSTRING,LPCSTR); -static VOID (WINAPI *pRtlInitString)(PSTRING, LPCSTR); -/*static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING);*/ +static NTSTATUS (WINAPI *pRtlCharToInteger)(char *, ULONG, int *); +static VOID (WINAPI *pRtlCopyString)(STRING *, const STRING *); +static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR); +static BOOLEAN (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN); +static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING); +static VOID (WINAPI *pRtlInitAnsiString)(PSTRING, LPCSTR); +static VOID (WINAPI *pRtlInitString)(PSTRING, LPCSTR); +static VOID (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING, LPCWSTR); +static NTSTATUS (WINAPI *pRtlIntegerToChar)(ULONG, ULONG, ULONG, PCHAR); +static NTSTATUS (WINAPI *pRtlIntegerToUnicodeString)(ULONG, ULONG, UNICODE_STRING *); +static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN); +static NTSTATUS (WINAPI *pRtlUnicodeStringToInteger)(const UNICODE_STRING *, int, int *); +static WCHAR (WINAPI *pRtlUpcaseUnicodeChar)(WCHAR); +static NTSTATUS (WINAPI *pRtlUpcaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN); +static CHAR (WINAPI *pRtlUpperChar)(CHAR); +static NTSTATUS (WINAPI *pRtlUpperString)(STRING *, const STRING *); + /*static VOID (WINAPI *pRtlFreeOemString)(PSTRING);*/ -static VOID (WINAPI *pRtlCopyString)(STRING *, const STRING *); -static VOID (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING,LPCWSTR); -static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING,LPCWSTR); /*static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING,LPCSTR);*/ /*static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);*/ /*static VOID (WINAPI *pRtlCopyUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *);*/ @@ -48,28 +60,21 @@ static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING,LPCWSTR); /*static LONG (WINAPI *pRtlCompareString)(const STRING *,const STRING *,BOOLEAN);*/ /*static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING *,const UNICODE_STRING *,BOOLEAN);*/ /*static BOOLEAN (WINAPI *pRtlEqualString)(const STRING *,const STRING *,BOOLEAN);*/ -/*static BOOLEAN (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *,const UNICODE_STRING *,BOOLEAN);*/ /*static BOOLEAN (WINAPI *pRtlPrefixString)(const STRING *, const STRING *, BOOLEAN);*/ /*static BOOLEAN (WINAPI *pRtlPrefixUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlOemStringToUnicodeString)(PUNICODE_STRING, const STRING *, BOOLEAN);*/ -/*static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/ /*static NTSTATUS (WINAPI *pRtlOemToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/ -/*static NTSTATUS (WINAPI *pRtlUpperString)(STRING *, const STRING *);*/ -/*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/ /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToMultiByteN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/ /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToOemN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/ /*static UINT (WINAPI *pRtlOemToUnicodeSize)(const STRING *);*/ /*static DWORD (WINAPI *pRtlAnsiStringToUnicodeSize)(const STRING *);*/ - -/* more function pointers here */ - /*static DWORD (WINAPI *pRtlIsTextUnicode)(LPVOID, DWORD, DWORD *);*/ -static NTSTATUS (WINAPI *pRtlUnicodeStringToInteger)(const UNICODE_STRING *, int, int *); + static WCHAR* AtoW( char* p ) { @@ -80,21 +85,32 @@ static WCHAR* AtoW( char* p ) return buffer; } -static void InitFunctionPtrs() + +static void InitFunctionPtrs(void) { - hntdll = LoadLibraryA("ntdll.dll"); - ok(hntdll != 0, "LoadLibrary failed"); - if (hntdll) - { + hntdll = LoadLibraryA("ntdll.dll"); + ok(hntdll != 0, "LoadLibrary failed"); + if (hntdll) { + pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger"); + pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString"); + pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString"); + pRtlEqualUnicodeString = (void *)GetProcAddress(hntdll, "RtlEqualUnicodeString"); + pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString"); pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString"); pRtlInitString = (void *)GetProcAddress(hntdll, "RtlInitString"); pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString"); - pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString"); - pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString"); + pRtlIntegerToChar = (void *)GetProcAddress(hntdll, "RtlIntegerToChar"); + pRtlIntegerToUnicodeString = (void *)GetProcAddress(hntdll, "RtlIntegerToUnicodeString"); + pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString"); pRtlUnicodeStringToInteger = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToInteger"); - } + pRtlUpcaseUnicodeChar = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeChar"); + pRtlUpcaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeString"); + pRtlUpperChar = (void *)GetProcAddress(hntdll, "RtlUpperChar"); + pRtlUpperString = (void *)GetProcAddress(hntdll, "RtlUpperString"); + } /* if */ } + static void test_RtlInitString(void) { static const char teststring[] = "Some Wild String"; @@ -104,9 +120,16 @@ static void test_RtlInitString(void) pRtlInitString(&str, teststring); ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized"); ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized"); + ok(str.Buffer == teststring, "Buffer not equal to teststring"); ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to"); + pRtlInitString(&str, NULL); + ok(str.Length == 0, "Length uninitialized"); + ok(str.MaximumLength == 0, "MaximumLength uninitialized"); + ok(str.Buffer == NULL, "Buffer not equal to NULL"); +/* pRtlInitString(NULL, teststring); */ } + static void test_RtlInitUnicodeString(void) { #define STRINGW {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0} @@ -119,9 +142,16 @@ static void test_RtlInitUnicodeString(void) pRtlInitUnicodeString(&uni, teststring); ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized"); ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized"); + ok(uni.Buffer == teststring, "Buffer not equal to teststring"); ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to"); + pRtlInitUnicodeString(&uni, NULL); + ok(uni.Length == 0, "Length uninitialized"); + ok(uni.MaximumLength == 0, "MaximumLength uninitialized"); + ok(uni.Buffer == NULL, "Buffer not equal to NULL"); +/* pRtlInitUnicodeString(NULL, teststring); */ } + static void test_RtlCopyString(void) { static const char teststring[] = "Some Wild String"; @@ -133,78 +163,618 @@ static void test_RtlCopyString(void) ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied"); } + +static void test_RtlUpperChar(void) +{ + int ch; + int upper_ch; + int expected_upper_ch; + int byte_ch; + + for (ch = -1; ch <= 1024; ch++) { + upper_ch = pRtlUpperChar(ch); + byte_ch = ch & 0xff; + if (byte_ch >= 'a' && byte_ch <= 'z') { + expected_upper_ch = (CHAR) (byte_ch - 'a' + 'A'); + } else { + expected_upper_ch = (CHAR) byte_ch; + } /* if */ + ok(upper_ch == expected_upper_ch, + "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]", + ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch); + } /* for */ +} + + +static void test_RtlUpperString(void) +{ + int i; + CHAR ch; + CHAR upper_ch; + char ascii_buf[257]; + char result_buf[257]; + char upper_buf[257]; + STRING ascii_str; + STRING result_str; + STRING upper_str; + + for (i = 0; i <= 255; i++) { + ch = (CHAR) i; + if (ch >= 'a' && ch <= 'z') { + upper_ch = ch - 'a' + 'A'; + } else { + upper_ch = ch; + } + ascii_buf[i] = ch; + result_buf[i] = '\0'; + upper_buf[i] = upper_ch; + } /* for */ + ascii_buf[i] = '\0'; + result_buf[i] = '\0'; + upper_buf[i] = '\0'; + ascii_str.Length = 256; + ascii_str.MaximumLength = 256; + ascii_str.Buffer = ascii_buf; + result_str.Length = 256; + result_str.MaximumLength = 256; + result_str.Buffer = result_buf; + upper_str.Length = 256; + upper_str.MaximumLength = 256; + upper_str.Buffer = upper_buf; + + pRtlUpperString(&result_str, &ascii_str); + ok(memcmp(result_str.Buffer, upper_str.Buffer, 256) == 0, + "RtlUpperString does not work as expected"); +} + + +static void test_RtlUpcaseUnicodeChar(void) +{ + int i; + WCHAR ch; + WCHAR upper_ch; + WCHAR expected_upper_ch; + + for (i = 0; i <= 255; i++) { + ch = (WCHAR) i; + upper_ch = pRtlUpcaseUnicodeChar(ch); + if (ch >= 'a' && ch <= 'z') { + expected_upper_ch = ch - 'a' + 'A'; + } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) { + expected_upper_ch = ch - 0x20; + } else if (ch == 0xff) { + expected_upper_ch = 0x178; + } else { + expected_upper_ch = ch; + } /* if */ + ok(upper_ch == expected_upper_ch, + "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]", + ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch); + } /* for */ +} + + +static void test_RtlUpcaseUnicodeString(void) +{ + int i; + WCHAR ch; + WCHAR upper_ch; + WCHAR ascii_buf[257]; + WCHAR result_buf[257]; + WCHAR upper_buf[257]; + UNICODE_STRING ascii_str; + UNICODE_STRING result_str; + UNICODE_STRING upper_str; + + for (i = 0; i <= 255; i++) { + ch = (WCHAR) i; + if (ch >= 'a' && ch <= 'z') { + upper_ch = ch - 'a' + 'A'; + } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) { + upper_ch = ch - 0x20; + } else if (ch == 0xff) { + upper_ch = 0x178; + } else { + upper_ch = ch; + } /* if */ + ascii_buf[i] = ch; + result_buf[i] = '\0'; + upper_buf[i] = upper_ch; + } /* for */ + ascii_buf[i] = '\0'; + result_buf[i] = '\0'; + upper_buf[i] = '\0'; + ascii_str.Length = 512; + ascii_str.MaximumLength = 512; + ascii_str.Buffer = ascii_buf; + result_str.Length = 512; + result_str.MaximumLength = 512; + result_str.Buffer = result_buf; + upper_str.Length = 512; + upper_str.MaximumLength = 512; + upper_str.Buffer = upper_buf; + + pRtlUpcaseUnicodeString(&result_str, &ascii_str, 0); + for (i = 0; i <= 255; i++) { + ok(result_str.Buffer[i] == upper_str.Buffer[i], + "RtlUpcaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]", + ascii_str.Buffer[i], ascii_str.Buffer[i], + result_str.Buffer[i], result_str.Buffer[i], + upper_str.Buffer[i], upper_str.Buffer[i]); + } /* for */ +} + + typedef struct { - char* str; + int base; + char *str; int value; + NTSTATUS result; } str2int_t; -static const str2int_t int_strings[] = { - {"1011101100",1011101100}, - {"1234567",1234567}, - {"2147483648",0x80000000L}, - {"-2147483648",0x80000000L}, - {"-214",-214}, - {" \n \r214",214}, - {"+214 0",214}, - {" 214.01",214}, - {"f81",0}, - {"0x12345",0x12345}, - {"1x34",1} +static const str2int_t str2int[] = { + { 0, "1011101100", 1011101100, STATUS_SUCCESS}, + { 0, "1234567", 1234567, STATUS_SUCCESS}, + { 0, "-214", -214, STATUS_SUCCESS}, + { 0, "+214", 214, STATUS_SUCCESS}, /* The + sign is allowed also */ + { 0, "--214", 0, STATUS_SUCCESS}, /* Do not accept more than one sign */ + { 0, "-+214", 0, STATUS_SUCCESS}, + { 0, "++214", 0, STATUS_SUCCESS}, + { 0, "+-214", 0, STATUS_SUCCESS}, + { 0, " \n \r \t214", 214, STATUS_SUCCESS}, + { 0, " \n \r \t+214", 214, STATUS_SUCCESS}, /* Signs can be used after whitespace */ + { 0, " \n \r \t-214", -214, STATUS_SUCCESS}, + { 0, "+214 0", 214, STATUS_SUCCESS}, /* Space terminates the number */ + { 0, " 214.01", 214, STATUS_SUCCESS}, /* Decimal point not accepted */ + { 0, " 214,01", 214, STATUS_SUCCESS}, /* Decimal comma not accepted */ + { 0, "f81", 0, STATUS_SUCCESS}, + { 0, "0x12345", 0x12345, STATUS_SUCCESS}, /* Hex */ + { 0, "00x12345", 0, STATUS_SUCCESS}, + { 0, "0xx12345", 0, STATUS_SUCCESS}, + { 0, "1x34", 1, STATUS_SUCCESS}, + { 0, "-9999999999", -1410065407, STATUS_SUCCESS}, /* Big negative integer */ + { 0, "-2147483649", 2147483647, STATUS_SUCCESS}, /* Too small to fit in 32 Bits */ + { 0, "-2147483648", 0x80000000L, STATUS_SUCCESS}, /* Smallest negative integer */ + { 0, "-2147483647", -2147483647, STATUS_SUCCESS}, + { 0, "-1", -1, STATUS_SUCCESS}, + { 0, "0", 0, STATUS_SUCCESS}, + { 0, "1", 1, STATUS_SUCCESS}, + { 0, "2147483646", 2147483646, STATUS_SUCCESS}, + { 0, "2147483647", 2147483647, STATUS_SUCCESS}, /* Largest signed positive integer */ + { 0, "2147483648", 0x80000000L, STATUS_SUCCESS}, /* Positive int equal to smallest negative int */ + { 0, "2147483649", -2147483647, STATUS_SUCCESS}, + { 0, "4294967294", -2, STATUS_SUCCESS}, + { 0, "4294967295", -1, STATUS_SUCCESS}, /* Largest unsigned integer */ + { 0, "4294967296", 0, STATUS_SUCCESS}, /* Too big to fit in 32 Bits */ + { 0, "9999999999", 1410065407, STATUS_SUCCESS}, /* Big positive integer */ + { 0, "056789", 56789, STATUS_SUCCESS}, /* Leading zero and still decimal */ + { 0, "b1011101100", 0, STATUS_SUCCESS}, /* Binary (b-notation) */ + { 0, "-b1011101100", 0, STATUS_SUCCESS}, /* Negative Binary (b-notation) */ + { 0, "b10123456789", 0, STATUS_SUCCESS}, /* Binary with nonbinary digits (2-9) */ + { 0, "0b1011101100", 748, STATUS_SUCCESS}, /* Binary (0b-notation) */ + { 0, "-0b1011101100", -748, STATUS_SUCCESS}, /* Negative binary (0b-notation) */ + { 0, "0b10123456789", 5, STATUS_SUCCESS}, /* Binary with nonbinary digits (2-9) */ + { 0, "-0b10123456789", -5, STATUS_SUCCESS}, /* Negative binary with nonbinary digits (2-9) */ + { 0, "0b1", 1, STATUS_SUCCESS}, /* one digit binary */ + { 0, "0b2", 0, STATUS_SUCCESS}, /* empty binary */ + { 0, "0b", 0, STATUS_SUCCESS}, /* empty binary */ + { 0, "o1234567", 0, STATUS_SUCCESS}, /* Octal (o-notation) */ + { 0, "-o1234567", 0, STATUS_SUCCESS}, /* Negative Octal (o-notation) */ + { 0, "o56789", 0, STATUS_SUCCESS}, /* Octal with nonoctal digits (8 and 9) */ + { 0, "0o1234567", 01234567, STATUS_SUCCESS}, /* Octal (0o-notation) */ + { 0, "-0o1234567", -01234567, STATUS_SUCCESS}, /* Negative octal (0o-notation) */ + { 0, "0o56789", 0567, STATUS_SUCCESS}, /* Octal with nonoctal digits (8 and 9) */ + { 0, "-0o56789", -0567, STATUS_SUCCESS}, /* Negative octal with nonoctal digits (8 and 9) */ + { 0, "0o7", 7, STATUS_SUCCESS}, /* one digit octal */ + { 0, "0o8", 0, STATUS_SUCCESS}, /* empty octal */ + { 0, "0o", 0, STATUS_SUCCESS}, /* empty octal */ + { 0, "0d1011101100", 0, STATUS_SUCCESS}, /* explizit decimal with 0d */ + { 0, "x89abcdef", 0, STATUS_SUCCESS}, /* Hex with lower case digits a-f (x-notation) */ + { 0, "xFEDCBA00", 0, STATUS_SUCCESS}, /* Hex with upper case digits A-F (x-notation) */ + { 0, "-xFEDCBA00", 0, STATUS_SUCCESS}, /* Negative Hexadecimal (x-notation) */ + { 0, "0x89abcdef", 0x89abcdef, STATUS_SUCCESS}, /* Hex with lower case digits a-f (0x-notation) */ + { 0, "0xFEDCBA00", 0xFEDCBA00, STATUS_SUCCESS}, /* Hex with upper case digits A-F (0x-notation) */ + { 0, "-0xFEDCBA00", -0xFEDCBA00, STATUS_SUCCESS}, /* Negative Hexadecimal (0x-notation) */ + { 0, "0xabcdefgh", 0xabcdef, STATUS_SUCCESS}, /* Hex with illegal lower case digits (g-z) */ + { 0, "0xABCDEFGH", 0xABCDEF, STATUS_SUCCESS}, /* Hex with illegal upper case digits (G-Z) */ + { 0, "0xF", 0xf, STATUS_SUCCESS}, /* one digit hexadecimal */ + { 0, "0xG", 0, STATUS_SUCCESS}, /* empty hexadecimal */ + { 0, "0x", 0, STATUS_SUCCESS}, /* empty hexadecimal */ + { 0, "", 0, STATUS_SUCCESS}, /* empty string */ + { 2, "1011101100", 748, STATUS_SUCCESS}, + { 2, "-1011101100", -748, STATUS_SUCCESS}, + { 2, "2", 0, STATUS_SUCCESS}, + { 2, "0b1011101100", 0, STATUS_SUCCESS}, + { 2, "0o1011101100", 0, STATUS_SUCCESS}, + { 2, "0d1011101100", 0, STATUS_SUCCESS}, + { 2, "0x1011101100", 0, STATUS_SUCCESS}, + { 2, "", 0, STATUS_SUCCESS}, /* empty string */ + { 8, "1011101100", 136610368, STATUS_SUCCESS}, + { 8, "-1011101100", -136610368, STATUS_SUCCESS}, + { 8, "8", 0, STATUS_SUCCESS}, + { 8, "0b1011101100", 0, STATUS_SUCCESS}, + { 8, "0o1011101100", 0, STATUS_SUCCESS}, + { 8, "0d1011101100", 0, STATUS_SUCCESS}, + { 8, "0x1011101100", 0, STATUS_SUCCESS}, + { 8, "", 0, STATUS_SUCCESS}, /* empty string */ + {10, "1011101100", 1011101100, STATUS_SUCCESS}, + {10, "-1011101100", -1011101100, STATUS_SUCCESS}, + {10, "0b1011101100", 0, STATUS_SUCCESS}, + {10, "0o1011101100", 0, STATUS_SUCCESS}, + {10, "0d1011101100", 0, STATUS_SUCCESS}, + {10, "0x1011101100", 0, STATUS_SUCCESS}, + {10, "o12345", 0, STATUS_SUCCESS}, /* Octal altrough base is 10 */ + {10, "", 0, STATUS_SUCCESS}, /* empty string */ + {16, "1011101100", 286265600, STATUS_SUCCESS}, + {16, "-1011101100", -286265600, STATUS_SUCCESS}, + {16, "G", 0, STATUS_SUCCESS}, + {16, "g", 0, STATUS_SUCCESS}, + {16, "0b1011101100", 286265600, STATUS_SUCCESS}, + {16, "0o1011101100", 0, STATUS_SUCCESS}, + {16, "0d1011101100", 286265600, STATUS_SUCCESS}, + {16, "0x1011101100", 0, STATUS_SUCCESS}, + {16, "", 0, STATUS_SUCCESS}, /* empty string */ + {20, "0", 0xdeadbeef, STATUS_INVALID_PARAMETER}, /* illegal base */ + {-8, "0", 0xdeadbeef, STATUS_INVALID_PARAMETER}, /* Negative base */ +/* { 0, NULL, 0, STATUS_SUCCESS}, */ /* NULL as string */ }; -#define NB_INT_STRINGS (sizeof(int_strings)/sizeof(*int_strings)) +#define NB_STR2INT (sizeof(str2int)/sizeof(*str2int)) -/* these are for int_strings[0]: */ -static const int expectedresultsbase[] = { - 748, /* base 2 */ - 136610368, /* base 8 */ - 1011101100, /* base 10 */ - 286265600, /* base 16 */ -}; static void test_RtlUnicodeStringToInteger(void) { - int dest = 0; - int i; - DWORD result; - WCHAR* wstr; - - for (i = 0; i < NB_INT_STRINGS; i++) - { - wstr=AtoW(int_strings[i].str); - dest = 0xdeadbeef; - pRtlInitUnicodeString(&uni, wstr); - result = pRtlUnicodeStringToInteger(&uni, 0, &dest); - ok(result == 0, "call failed: RtlUnicodeStringToInteger(\"%s\", %d, [out])", int_strings[i].str, 0); - ok(dest == int_strings[i].value, "didn't return expected value (test %d): expected: %d, got: %d}", i, int_strings[i].value, dest); - free(wstr); - } + int test_num; + int value; + NTSTATUS result; + WCHAR *wstr; - wstr=AtoW(int_strings[0].str); + for (test_num = 0; test_num < NB_STR2INT; test_num++) { + wstr = AtoW(str2int[test_num].str); + value = 0xdeadbeef; pRtlInitUnicodeString(&uni, wstr); - result = pRtlUnicodeStringToInteger(&uni, 2, &dest); - ok(result == 0, "call failed: RtlUnicodeStringToInteger(\"%s\", %d, [out])", int_strings[0].str, 2); - ok(dest == expectedresultsbase[0], "didn't return expected value: \"%s\"; expected: %d, got: %d}", int_strings[0].str, expectedresultsbase[0], dest); - result = pRtlUnicodeStringToInteger(&uni, 8, &dest); - ok(result == 0, "call failed: RtlUnicodeStringToInteger(\"%s\", %d, [out])", int_strings[0].str, 8); - ok(dest == expectedresultsbase[1], "didn't return expected value: \"%s\"; expected: %d, got: %d}", int_strings[0].str, expectedresultsbase[1], dest); - result = pRtlUnicodeStringToInteger(&uni, 10, &dest); - ok(result == 0, "call failed: RtlUnicodeStringToInteger(\"%s\", %d, [out])", int_strings[0].str, 10); - ok(dest == expectedresultsbase[2], "didn't return expected value: \"%s\"; expected: %d, got: %d}", int_strings[0].str, expectedresultsbase[2], dest); - result = pRtlUnicodeStringToInteger(&uni, 16, &dest); - ok(result == 0, "call failed: RtlUnicodeStringToInteger(\"%s\", %d, [out])", int_strings[0].str, 16); - ok(dest == expectedresultsbase[3], "didn't return expected value: \"%s\"; expected: %d, got: %d}", int_strings[0].str, expectedresultsbase[3], dest); + result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value); + ok(result == str2int[test_num].result, + "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx", + test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result); + ok(value == str2int[test_num].value, + "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d", + test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value); free(wstr); + } /* for */ + + wstr = AtoW(str2int[1].str); + pRtlInitUnicodeString(&uni, wstr); + result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, NULL); + ok(result == STATUS_ACCESS_VIOLATION, + "call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %lx", + str2int[1].str, str2int[1].base, result); + result = pRtlUnicodeStringToInteger(&uni, 20, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %lx", + str2int[1].str, result); + + uni.Length = 10; /* Make Length shorter (5 WCHARS instead of 7) */ + result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value); + ok(result == STATUS_SUCCESS, + "call failed: RtlUnicodeStringToInteger(\"12345\", %d, [out]) has result %lx", + str2int[1].base, result); + ok(value == 12345, + "didn't return expected value (test a): expected: %d, got: %d", + 12345, value); + + uni.Length = 5; /* Use odd Length (2.5 WCHARS) */ + result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value); + ok(result == STATUS_SUCCESS, + "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %lx", + str2int[1].base, result); + ok(value == 12, + "didn't return expected value (test b): expected: %d, got: %d", + 12, value); + + uni.Length = 2; + result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value); + ok(result == STATUS_SUCCESS, + "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %lx", + str2int[1].base, result); + ok(value == 1, + "didn't return expected value (test c): expected: %d, got: %d", + 1, value); + /* w2k: uni.Length = 0 returns value 11234567 instead of 0 */ + free(wstr); } + +static void test_RtlCharToInteger(void) +{ + int test_num; + int value; + NTSTATUS result; + + for (test_num = 0; test_num < NB_STR2INT; test_num++) { + /* w2k skips a leading '\0' and processes the string after */ + if (str2int[test_num].str[0] != '\0') { + value = 0xdeadbeef; + result = pRtlCharToInteger(str2int[test_num].str, str2int[test_num].base, &value); + ok(result == str2int[test_num].result, + "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %lx, expected: %lx", + test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result); + ok(value == str2int[test_num].value, + "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d", + test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value); + } /* if */ + } /* for */ + + result = pRtlCharToInteger(str2int[1].str, str2int[1].base, NULL); + ok(result == STATUS_ACCESS_VIOLATION, + "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %lx", + str2int[1].str, str2int[1].base, result); + + result = pRtlCharToInteger(str2int[1].str, 20, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "call failed: RtlCharToInteger(\"%s\", 20, NULL) has result %lx", + str2int[1].str, result); +} + + +#define STRI_BUFFER_LENGTH 35 + +typedef struct { + int base; + ULONG value; + USHORT Length; + USHORT MaximumLength; + char *Buffer; + NTSTATUS result; +} int2str_t; + +static const int2str_t int2str[] = { + {10, 123, 3, 11, "123\0-------------------------------", STATUS_SUCCESS}, + + { 0, 0x80000000U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* min signed int */ + { 0, -2147483647, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS}, + { 0, -2, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS}, + { 0, -1, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, + { 0, 0, 1, 11, "0\0---------------------------------", STATUS_SUCCESS}, + { 0, 1, 1, 11, "1\0---------------------------------", STATUS_SUCCESS}, + { 0, 12, 2, 11, "12\0--------------------------------", STATUS_SUCCESS}, + { 0, 123, 3, 11, "123\0-------------------------------", STATUS_SUCCESS}, + { 0, 1234, 4, 11, "1234\0------------------------------", STATUS_SUCCESS}, + { 0, 12345, 5, 11, "12345\0-----------------------------", STATUS_SUCCESS}, + { 0, 123456, 6, 11, "123456\0----------------------------", STATUS_SUCCESS}, + { 0, 1234567, 7, 11, "1234567\0---------------------------", STATUS_SUCCESS}, + { 0, 12345678, 8, 11, "12345678\0--------------------------", STATUS_SUCCESS}, + { 0, 123456789, 9, 11, "123456789\0-------------------------", STATUS_SUCCESS}, + { 0, 2147483646, 10, 11, "2147483646\0------------------------", STATUS_SUCCESS}, + { 0, 2147483647, 10, 11, "2147483647\0------------------------", STATUS_SUCCESS}, /* max signed int */ + { 0, 2147483648U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* uint = -max int */ + { 0, 2147483649U, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS}, + { 0, 4294967294U, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS}, + { 0, 4294967295U, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, /* max unsigned int */ + + { 2, 0x80000000U, 32, 33, "10000000000000000000000000000000\0--", STATUS_SUCCESS}, /* min signed int */ + { 2, -2147483647, 32, 33, "10000000000000000000000000000001\0--", STATUS_SUCCESS}, + { 2, -2, 32, 33, "11111111111111111111111111111110\0--", STATUS_SUCCESS}, + { 2, -1, 32, 33, "11111111111111111111111111111111\0--", STATUS_SUCCESS}, + { 2, 0, 1, 33, "0\0---------------------------------", STATUS_SUCCESS}, + { 2, 1, 1, 33, "1\0---------------------------------", STATUS_SUCCESS}, + { 2, 10, 4, 33, "1010\0------------------------------", STATUS_SUCCESS}, + { 2, 100, 7, 33, "1100100\0---------------------------", STATUS_SUCCESS}, + { 2, 1000, 10, 33, "1111101000\0------------------------", STATUS_SUCCESS}, + { 2, 10000, 14, 33, "10011100010000\0--------------------", STATUS_SUCCESS}, + { 2, 32767, 15, 33, "111111111111111\0-------------------", STATUS_SUCCESS}, + { 2, 32768, 16, 33, "1000000000000000\0------------------", STATUS_SUCCESS}, + { 2, 65535, 16, 33, "1111111111111111\0------------------", STATUS_SUCCESS}, + { 2, 65536, 17, 33, "10000000000000000\0-----------------", STATUS_SUCCESS}, + { 2, 100000, 17, 33, "11000011010100000\0-----------------", STATUS_SUCCESS}, + { 2, 1000000, 20, 33, "11110100001001000000\0--------------", STATUS_SUCCESS}, + { 2, 10000000, 24, 33, "100110001001011010000000\0----------", STATUS_SUCCESS}, + { 2, 100000000, 27, 33, "101111101011110000100000000\0-------", STATUS_SUCCESS}, + { 2, 1000000000, 30, 33, "111011100110101100101000000000\0----", STATUS_SUCCESS}, + { 2, 1073741823, 30, 33, "111111111111111111111111111111\0----", STATUS_SUCCESS}, + { 2, 2147483646, 31, 33, "1111111111111111111111111111110\0---", STATUS_SUCCESS}, + { 2, 2147483647, 31, 33, "1111111111111111111111111111111\0---", STATUS_SUCCESS}, /* max signed int */ + { 2, 2147483648U, 32, 33, "10000000000000000000000000000000\0--", STATUS_SUCCESS}, /* uint = -max int */ + { 2, 2147483649U, 32, 33, "10000000000000000000000000000001\0--", STATUS_SUCCESS}, + { 2, 4294967294U, 32, 33, "11111111111111111111111111111110\0--", STATUS_SUCCESS}, + { 2, 4294967295U, 32, 33, "11111111111111111111111111111111\0--", STATUS_SUCCESS}, /* max unsigned int */ + + { 8, 0x80000000U, 11, 12, "20000000000\0-----------------------", STATUS_SUCCESS}, /* min signed int */ + { 8, -2147483647, 11, 12, "20000000001\0-----------------------", STATUS_SUCCESS}, + { 8, -2, 11, 12, "37777777776\0-----------------------", STATUS_SUCCESS}, + { 8, -1, 11, 12, "37777777777\0-----------------------", STATUS_SUCCESS}, + { 8, 0, 1, 12, "0\0---------------------------------", STATUS_SUCCESS}, + { 8, 1, 1, 12, "1\0---------------------------------", STATUS_SUCCESS}, + { 8, 2147483646, 11, 12, "17777777776\0-----------------------", STATUS_SUCCESS}, + { 8, 2147483647, 11, 12, "17777777777\0-----------------------", STATUS_SUCCESS}, /* max signed int */ + { 8, 2147483648U, 11, 12, "20000000000\0-----------------------", STATUS_SUCCESS}, /* uint = -max int */ + { 8, 2147483649U, 11, 12, "20000000001\0-----------------------", STATUS_SUCCESS}, + { 8, 4294967294U, 11, 12, "37777777776\0-----------------------", STATUS_SUCCESS}, + { 8, 4294967295U, 11, 12, "37777777777\0-----------------------", STATUS_SUCCESS}, /* max unsigned int */ + + {10, 0x80000000U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* min signed int */ + {10, -2147483647, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS}, + {10, -2, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS}, + {10, -1, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, + {10, 0, 1, 11, "0\0---------------------------------", STATUS_SUCCESS}, + {10, 1, 1, 11, "1\0---------------------------------", STATUS_SUCCESS}, + {10, 2147483646, 10, 11, "2147483646\0------------------------", STATUS_SUCCESS}, + {10, 2147483647, 10, 11, "2147483647\0------------------------", STATUS_SUCCESS}, /* max signed int */ + {10, 2147483648U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* uint = -max int */ + {10, 2147483649U, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS}, + {10, 4294967294U, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS}, + {10, 4294967295U, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, /* max unsigned int */ + + {16, 0x80000000U, 8, 9, "80000000\0--------------------------", STATUS_SUCCESS}, /* min signed int */ + {16, -2147483647, 8, 9, "80000001\0--------------------------", STATUS_SUCCESS}, + {16, -2, 8, 9, "FFFFFFFE\0--------------------------", STATUS_SUCCESS}, + {16, -1, 8, 9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS}, + {16, 0, 1, 9, "0\0---------------------------------", STATUS_SUCCESS}, + {16, 1, 1, 9, "1\0---------------------------------", STATUS_SUCCESS}, + {16, 2147483646, 8, 9, "7FFFFFFE\0--------------------------", STATUS_SUCCESS}, + {16, 2147483647, 8, 9, "7FFFFFFF\0--------------------------", STATUS_SUCCESS}, /* max signed int */ + {16, 2147483648U, 8, 9, "80000000\0--------------------------", STATUS_SUCCESS}, /* uint = -max int */ + {16, 2147483649U, 8, 9, "80000001\0--------------------------", STATUS_SUCCESS}, + {16, 4294967294U, 8, 9, "FFFFFFFE\0--------------------------", STATUS_SUCCESS}, + {16, 4294967295U, 8, 9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS}, /* max unsigned int */ + + { 2, 32768, 16, 17, "1000000000000000\0------------------", STATUS_SUCCESS}, + { 2, 32768, 16, 16, "1000000000000000-------------------", STATUS_SUCCESS}, + { 2, 65536, 17, 18, "10000000000000000\0-----------------", STATUS_SUCCESS}, + { 2, 65536, 17, 17, "10000000000000000------------------", STATUS_SUCCESS}, + { 2, 131072, 18, 19, "100000000000000000\0----------------", STATUS_SUCCESS}, + { 2, 131072, 18, 18, "100000000000000000-----------------", STATUS_SUCCESS}, + {16, 0xffffffff, 8, 9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS}, + {16, 0xffffffff, 8, 8, "FFFFFFFF---------------------------", STATUS_SUCCESS}, /* No \0 term */ + {16, 0xffffffff, 8, 7, "-----------------------------------", STATUS_BUFFER_OVERFLOW}, /* Too short */ + {16, 0xa, 1, 2, "A\0---------------------------------", STATUS_SUCCESS}, + {16, 0xa, 1, 1, "A----------------------------------", STATUS_SUCCESS}, /* No \0 term */ + {16, 0, 1, 0, "-----------------------------------", STATUS_BUFFER_OVERFLOW}, + {20, 0xdeadbeef, 0, 9, "-----------------------------------", STATUS_INVALID_PARAMETER}, /* ill. base */ + {-8, 07654321, 0, 12, "-----------------------------------", STATUS_INVALID_PARAMETER}, /* neg. base */ +}; +#define NB_INT2STR (sizeof(int2str)/sizeof(*int2str)) + + +static void one_RtlIntegerToUnicodeString_test(int test_num, const int2str_t *int2str) +{ + int pos; + WCHAR expected_str_Buffer[STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING expected_unicode_string; + STRING expected_ansi_str; + WCHAR str_Buffer[STRI_BUFFER_LENGTH + 1]; + UNICODE_STRING unicode_string; + STRING ansi_str; + NTSTATUS result; + + for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) { + expected_str_Buffer[pos] = int2str->Buffer[pos]; + } /* for */ + expected_unicode_string.Length = int2str->Length * sizeof(WCHAR); + expected_unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR); + expected_unicode_string.Buffer = expected_str_Buffer; + pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1); + + for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) { + str_Buffer[pos] = '-'; + } /* for */ + unicode_string.Length = 0; + unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR); + unicode_string.Buffer = str_Buffer; + + result = pRtlIntegerToUnicodeString(int2str->value, int2str->base, &unicode_string); + pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1); + if (result == STATUS_BUFFER_OVERFLOW) { + /* On BUFFER_OVERFLOW the string Buffer should be unchanged */ + for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) { + expected_str_Buffer[pos] = '-'; + } /* for */ + /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */ + /* If the value is too large to convert: The Length is unchanged */ + /* If str is too small to hold the string: Set str->Length to the length */ + /* the string would have (which can be larger than the MaximumLength). */ + /* To allow all this in the tests we do the following: */ + if (expected_unicode_string.Length > 32 && unicode_string.Length == 0) { + /* The value is too large to convert only triggerd when testing native */ + expected_unicode_string.Length = 0; + } /* if */ + } else { + ok(result == int2str->result, + "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) has result %lx, expected: %lx", + test_num, int2str->value, int2str->base, result, int2str->result); + if (result == STATUS_SUCCESS) { + ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0', + "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string \"%s\" is not NULL terminated", + test_num, int2str->value, int2str->base, ansi_str.Buffer); + } /* if */ + } /* if */ + ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, + "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) assigns string \"%s\", expected: \"%s\"", + test_num, int2str->value, int2str->base, ansi_str.Buffer, expected_ansi_str.Buffer); + ok(unicode_string.Length == expected_unicode_string.Length, + "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has Length %d, expected: %d", + test_num, int2str->value, int2str->base, unicode_string.Length, expected_unicode_string.Length); + ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength, + "(test %d): RtlIntegerToUnicodeString(%lu, %d, [out]) string has MaximumLength %d, expected: %d", + test_num, int2str->value, int2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength); + pRtlFreeAnsiString(&expected_ansi_str); + pRtlFreeAnsiString(&ansi_str); +} + + +static void test_RtlIntegerToUnicodeString(void) +{ + int test_num; + + for (test_num = 0; test_num < NB_INT2STR; test_num++) { + one_RtlIntegerToUnicodeString_test(test_num, &int2str[test_num]); + } /* for */ +} + + +static void one_RtlIntegerToChar_test(int test_num, const int2str_t *int2str) +{ + NTSTATUS result; + char dest_str[STRI_BUFFER_LENGTH + 1]; + + memset(dest_str, '-', STRI_BUFFER_LENGTH); + dest_str[STRI_BUFFER_LENGTH] = '\0'; + result = pRtlIntegerToChar(int2str->value, int2str->base, int2str->MaximumLength, dest_str); + ok(result == int2str->result, + "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) has result %lx, expected: %lx", + test_num, int2str->value, int2str->base, int2str->MaximumLength, result, int2str->result); + ok(memcmp(dest_str, int2str->Buffer, STRI_BUFFER_LENGTH) == 0, + "(test %d): RtlIntegerToChar(%lu, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"", + test_num, int2str->value, int2str->base, int2str->MaximumLength, dest_str, int2str->Buffer); +} + + +static void test_RtlIntegerToChar(void) +{ + NTSTATUS result; + int test_num; + + for (test_num = 0; test_num < NB_INT2STR; test_num++) { + one_RtlIntegerToChar_test(test_num, &int2str[test_num]); + } /* for */ + + result = pRtlIntegerToChar(int2str[0].value, 20, int2str[0].MaximumLength, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "(test a): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x", + int2str[0].value, 20, int2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER); + + result = pRtlIntegerToChar(int2str[0].value, 20, 0, NULL); + ok(result == STATUS_INVALID_PARAMETER, + "(test b): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x", + int2str[0].value, 20, 0, result, STATUS_INVALID_PARAMETER); + + result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, 0, NULL); + ok(result == STATUS_BUFFER_OVERFLOW, + "(test c): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x", + int2str[0].value, int2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW); + + result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, int2str[0].MaximumLength, NULL); + ok(result == STATUS_ACCESS_VIOLATION, + "(test d): RtlIntegerToChar(%lu, %d, %d, NULL) has result %lx, expected: %x", + int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION); +} + + START_TEST(rtlstr) { - InitFunctionPtrs(); - - if (pRtlInitAnsiString) - { - test_RtlInitString(); - test_RtlInitUnicodeString(); - test_RtlCopyString(); - test_RtlUnicodeStringToInteger(); - } + InitFunctionPtrs(); + if (pRtlInitAnsiString) { + test_RtlInitString(); + test_RtlInitUnicodeString(); + test_RtlCopyString(); + test_RtlUnicodeStringToInteger(); + test_RtlCharToInteger(); + test_RtlIntegerToUnicodeString(); + test_RtlIntegerToChar(); + test_RtlUpperChar(); + test_RtlUpperString(); + } /* if */ + /* + * test_RtlUpcaseUnicodeChar(); + * test_RtlUpcaseUnicodeString(); + */ }