/* 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 * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * NOTES * We use function pointers here as there is no import library for NTDLL on * windows. */ #include #define INITGUID #include "ntdll_test.h" #include "winnls.h" #include "guiddef.h" #define HASH_STRING_ALGORITHM_X65599 1 #define HASH_STRING_ALGORITHM_INVALID 0xffffffff /* Function ptrs for ntdll calls */ static HMODULE hntdll = 0; static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN); static NTSTATUS (WINAPI *pRtlAppendAsciizToString)(STRING *, LPCSTR); static NTSTATUS (WINAPI *pRtlAppendStringToString)(STRING *, const STRING *); static NTSTATUS (WINAPI *pRtlAppendUnicodeStringToString)(UNICODE_STRING *, const UNICODE_STRING *); static NTSTATUS (WINAPI *pRtlAppendUnicodeToString)(UNICODE_STRING *, LPCWSTR); static NTSTATUS (WINAPI *pRtlCharToInteger)(PCSZ, ULONG, int *); static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING*, const UNICODE_STRING*, BOOLEAN); static LONG (WINAPI *pRtlCompareUnicodeStrings)(const WCHAR *,SIZE_T,const WCHAR *,SIZE_T,BOOLEAN); static VOID (WINAPI *pRtlCopyString)(STRING *, const STRING *); static BOOLEAN (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR); static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR); static NTSTATUS (WINAPI *pRtlDowncaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN); static NTSTATUS (WINAPI *pRtlDuplicateUnicodeString)(int, UNICODE_STRING *, UNICODE_STRING *); static BOOLEAN (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN); static NTSTATUS (WINAPI *pRtlFindCharInUnicodeString)(int, const UNICODE_STRING *, const UNICODE_STRING *, USHORT *); static VOID (WINAPI *pRtlFreeAnsiString)(PSTRING); static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING); static VOID (WINAPI *pRtlInitAnsiString)(PSTRING, LPCSTR); static VOID (WINAPI *pRtlInitString)(PSTRING, LPCSTR); static VOID (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING, LPCWSTR); static NTSTATUS (WINAPI *pRtlInitUnicodeStringEx)(PUNICODE_STRING, LPCWSTR); static NTSTATUS (WINAPI *pRtlIntegerToChar)(ULONG, ULONG, ULONG, PCHAR); static NTSTATUS (WINAPI *pRtlIntegerToUnicodeString)(ULONG, ULONG, UNICODE_STRING *); static NTSTATUS (WINAPI *pRtlMultiAppendUnicodeStringBuffer)(UNICODE_STRING *, LONG, 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 NTSTATUS (WINAPI *pRtlValidateUnicodeString)(LONG, UNICODE_STRING *); static NTSTATUS (WINAPI *pRtlGUIDFromString)(const UNICODE_STRING*,GUID*); static NTSTATUS (WINAPI *pRtlStringFromGUID)(const GUID*, UNICODE_STRING*); static BOOLEAN (WINAPI *pRtlIsTextUnicode)(LPVOID, INT, INT *); static NTSTATUS (WINAPI *pRtlHashUnicodeString)(PCUNICODE_STRING,BOOLEAN,ULONG,ULONG*); static NTSTATUS (WINAPI *pRtlUnicodeToUTF8N)(CHAR *, ULONG, ULONG *, const WCHAR *, ULONG); static NTSTATUS (WINAPI *pRtlUTF8ToUnicodeN)(WCHAR *, ULONG, ULONG *, const CHAR *, ULONG); /*static VOID (WINAPI *pRtlFreeOemString)(PSTRING);*/ /*static VOID (WINAPI *pRtlCopyUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *);*/ /*static VOID (WINAPI *pRtlEraseUnicodeString)(UNICODE_STRING *);*/ /*static LONG (WINAPI *pRtlCompareString)(const STRING *,const STRING *,BOOLEAN);*/ /*static BOOLEAN (WINAPI *pRtlEqualString)(const STRING *,const 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 *pRtlOemStringToUnicodeString)(PUNICODE_STRING, const 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 *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 *);*/ static WCHAR* AtoW( const char* p ) { WCHAR* buffer; DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 ); buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) ); MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len ); return buffer; } static void InitFunctionPtrs(void) { hntdll = LoadLibraryA("ntdll.dll"); ok(hntdll != 0, "LoadLibrary failed\n"); if (hntdll) { pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString"); pRtlAppendAsciizToString = (void *)GetProcAddress(hntdll, "RtlAppendAsciizToString"); pRtlAppendStringToString = (void *)GetProcAddress(hntdll, "RtlAppendStringToString"); pRtlAppendUnicodeStringToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeStringToString"); pRtlAppendUnicodeToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeToString"); pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger"); pRtlCompareUnicodeString = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeString"); pRtlCompareUnicodeStrings = (void *)GetProcAddress(hntdll, "RtlCompareUnicodeStrings"); pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString"); pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString"); pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz"); pRtlDowncaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlDowncaseUnicodeString"); pRtlDuplicateUnicodeString = (void *)GetProcAddress(hntdll, "RtlDuplicateUnicodeString"); pRtlEqualUnicodeString = (void *)GetProcAddress(hntdll, "RtlEqualUnicodeString"); pRtlFindCharInUnicodeString = (void *)GetProcAddress(hntdll, "RtlFindCharInUnicodeString"); pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString"); pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString"); pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString"); pRtlInitString = (void *)GetProcAddress(hntdll, "RtlInitString"); pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString"); pRtlInitUnicodeStringEx = (void *)GetProcAddress(hntdll, "RtlInitUnicodeStringEx"); pRtlIntegerToChar = (void *)GetProcAddress(hntdll, "RtlIntegerToChar"); pRtlIntegerToUnicodeString = (void *)GetProcAddress(hntdll, "RtlIntegerToUnicodeString"); pRtlMultiAppendUnicodeStringBuffer = (void *)GetProcAddress(hntdll, "RtlMultiAppendUnicodeStringBuffer"); 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"); pRtlValidateUnicodeString = (void *)GetProcAddress(hntdll, "RtlValidateUnicodeString"); pRtlGUIDFromString = (void *)GetProcAddress(hntdll, "RtlGUIDFromString"); pRtlStringFromGUID = (void *)GetProcAddress(hntdll, "RtlStringFromGUID"); pRtlIsTextUnicode = (void *)GetProcAddress(hntdll, "RtlIsTextUnicode"); pRtlHashUnicodeString = (void*)GetProcAddress(hntdll, "RtlHashUnicodeString"); pRtlUnicodeToUTF8N = (void*)GetProcAddress(hntdll, "RtlUnicodeToUTF8N"); pRtlUTF8ToUnicodeN = (void*)GetProcAddress(hntdll, "RtlUTF8ToUnicodeN"); } } static void test_RtlInitString(void) { static const char teststring[] = "Some Wild String"; STRING str; str.Length = 0; str.MaximumLength = 0; str.Buffer = (void *)0xdeadbeef; pRtlInitString(&str, teststring); ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized\n"); ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n"); ok(str.Buffer == teststring, "Buffer not equal to teststring\n"); ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to\n"); pRtlInitString(&str, NULL); ok(str.Length == 0, "Length uninitialized\n"); ok(str.MaximumLength == 0, "MaximumLength uninitialized\n"); ok(str.Buffer == NULL, "Buffer not equal to NULL\n"); /* 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} static const WCHAR teststring[] = STRINGW; static const WCHAR originalstring[] = STRINGW; #undef STRINGW UNICODE_STRING uni; uni.Length = 0; uni.MaximumLength = 0; uni.Buffer = (void *)0xdeadbeef; pRtlInitUnicodeString(&uni, teststring); ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized\n"); ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n"); ok(uni.Buffer == teststring, "Buffer not equal to teststring\n"); ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to\n"); pRtlInitUnicodeString(&uni, NULL); ok(uni.Length == 0, "Length uninitialized\n"); ok(uni.MaximumLength == 0, "MaximumLength uninitialized\n"); ok(uni.Buffer == NULL, "Buffer not equal to NULL\n"); /* pRtlInitUnicodeString(NULL, teststring); */ } #define TESTSTRING2_LEN 1000000 /* #define TESTSTRING2_LEN 32766 */ static void test_RtlInitUnicodeStringEx(void) { static const WCHAR teststring[] = {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0}; WCHAR *teststring2; UNICODE_STRING uni; NTSTATUS result; if (!pRtlInitUnicodeStringEx) { win_skip("RtlInitUnicodeStringEx is not available\n"); return; } teststring2 = HeapAlloc(GetProcessHeap(), 0, (TESTSTRING2_LEN + 1) * sizeof(WCHAR)); memset(teststring2, 'X', TESTSTRING2_LEN * sizeof(WCHAR)); teststring2[TESTSTRING2_LEN] = '\0'; uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; result = pRtlInitUnicodeStringEx(&uni, teststring); ok(result == STATUS_SUCCESS, "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected 0\n", result); ok(uni.Length == 32, "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n", uni.Length, 32); ok(uni.MaximumLength == 34, "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n", uni.MaximumLength, 34); ok(uni.Buffer == teststring, "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n", uni.Buffer, teststring); uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; pRtlInitUnicodeString(&uni, teststring); ok(uni.Length == 32, "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n", uni.Length, 32); ok(uni.MaximumLength == 34, "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n", uni.MaximumLength, 34); ok(uni.Buffer == teststring, "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n", uni.Buffer, teststring); uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; result = pRtlInitUnicodeStringEx(&uni, teststring2); ok(result == STATUS_NAME_TOO_LONG, "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected %x\n", result, STATUS_NAME_TOO_LONG); ok(uni.Length == 12345 || uni.Length == 0, /* win2k3 */ "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected 12345 or 0\n", uni.Length); ok(uni.MaximumLength == 12345 || uni.MaximumLength == 0, /* win2k3 */ "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected 12345 or 0\n", uni.MaximumLength); ok(uni.Buffer == (void *) 0xdeadbeef || uni.Buffer == teststring2, /* win2k3 */ "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x or %p\n", uni.Buffer, 0xdeadbeef, teststring2); uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; pRtlInitUnicodeString(&uni, teststring2); ok(uni.Length == 33920 /* <= Win2000 */ || uni.Length == 65532 /* >= Win XP */, "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n", uni.Length, 65532); ok(uni.MaximumLength == 33922 /* <= Win2000 */ || uni.MaximumLength == 65534 /* >= Win XP */, "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n", uni.MaximumLength, 65534); ok(uni.Buffer == teststring2, "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n", uni.Buffer, teststring2); ok(memcmp(uni.Buffer, teststring2, (TESTSTRING2_LEN + 1) * sizeof(WCHAR)) == 0, "pRtlInitUnicodeString(&uni, 0) changes Buffer\n"); uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; result = pRtlInitUnicodeStringEx(&uni, 0); ok(result == STATUS_SUCCESS, "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected 0\n", result); ok(uni.Length == 0, "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n", uni.Length, 0); ok(uni.MaximumLength == 0, "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n", uni.MaximumLength, 0); ok(uni.Buffer == NULL, "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n", uni.Buffer, NULL); uni.Length = 12345; uni.MaximumLength = 12345; uni.Buffer = (void *) 0xdeadbeef; pRtlInitUnicodeString(&uni, 0); ok(uni.Length == 0, "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n", uni.Length, 0); ok(uni.MaximumLength == 0, "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n", uni.MaximumLength, 0); ok(uni.Buffer == NULL, "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n", uni.Buffer, NULL); HeapFree(GetProcessHeap(), 0, teststring2); } typedef struct { int add_nul; int source_Length; int source_MaximumLength; int source_buf_size; const char *source_buf; int dest_Length; int dest_MaximumLength; int dest_buf_size; const char *dest_buf; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } dupl_ustr_t; static const dupl_ustr_t dupl_ustr[] = { { 0, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string", STATUS_SUCCESS}, { 0, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string", STATUS_SUCCESS}, { 0, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 0, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 32, 32, "This is a string", STATUS_SUCCESS}, { 0, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 32, 32, "This is a string", STATUS_SUCCESS}, { 0, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 1, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 1, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 1, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 1, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 1, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 32, 30, 34, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 3, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 3, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 3, 32, 30, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 3, 32, 34, 34, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 3, 32, 32, 32, "This is a string", 40, 42, 42, NULL, 32, 34, 34, "This is a string", STATUS_SUCCESS}, { 3, 32, 30, 32, "This is a string", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 4, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 6, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 7, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 8, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {10, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {11, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {12, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {13, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {14, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {15, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {16, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {-1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {-5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, {-9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 0, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 0, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 0, 0, 2, 2, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 0, 0, 0, 0, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 0, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 0, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 0, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 0, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 2, 2, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 0, 0, "", 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 1, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 0, 0, NULL, STATUS_SUCCESS}, { 1, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 1, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 0, 0, NULL, STATUS_SUCCESS}, { 2, 0, 2, 2, "", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 0, 0, 0, "", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 0, 2, 2, "", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 0, 0, 0, "", 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 2, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 2, 0, 0, 0, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 3, 0, 2, 2, "", 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS}, { 3, 0, 0, 0, "", 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS}, { 3, 0, 2, 2, "", 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS}, { 3, 0, 0, 0, "", 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS}, { 3, 0, 2, 2, NULL, 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER}, { 3, 0, 0, 0, NULL, 40, 42, 42, "--------------------", 0, 2, 2, "", STATUS_SUCCESS}, { 3, 0, 2, 2, NULL, 40, 42, 42, NULL, 40, 42, 0, NULL, STATUS_INVALID_PARAMETER}, { 3, 0, 0, 0, NULL, 40, 42, 42, NULL, 0, 2, 2, "", STATUS_SUCCESS}, }; static void test_RtlDuplicateUnicodeString(void) { size_t pos; WCHAR source_buf[257]; WCHAR dest_buf[257]; WCHAR res_buf[257]; UNICODE_STRING source_str; UNICODE_STRING dest_str; UNICODE_STRING res_str; CHAR dest_ansi_buf[257]; STRING dest_ansi_str; NTSTATUS result; unsigned int test_num; if (!pRtlDuplicateUnicodeString) { win_skip("RtlDuplicateUnicodeString is not available\n"); return; } for (test_num = 0; test_num < ARRAY_SIZE(dupl_ustr); test_num++) { source_str.Length = dupl_ustr[test_num].source_Length; source_str.MaximumLength = dupl_ustr[test_num].source_MaximumLength; if (dupl_ustr[test_num].source_buf != NULL) { for (pos = 0; pos < dupl_ustr[test_num].source_buf_size/sizeof(WCHAR); pos++) { source_buf[pos] = dupl_ustr[test_num].source_buf[pos]; } source_str.Buffer = source_buf; } else { source_str.Buffer = NULL; } dest_str.Length = dupl_ustr[test_num].dest_Length; dest_str.MaximumLength = dupl_ustr[test_num].dest_MaximumLength; if (dupl_ustr[test_num].dest_buf != NULL) { for (pos = 0; pos < dupl_ustr[test_num].dest_buf_size/sizeof(WCHAR); pos++) { dest_buf[pos] = dupl_ustr[test_num].dest_buf[pos]; } dest_str.Buffer = dest_buf; } else { dest_str.Buffer = NULL; } res_str.Length = dupl_ustr[test_num].res_Length; res_str.MaximumLength = dupl_ustr[test_num].res_MaximumLength; if (dupl_ustr[test_num].res_buf != NULL) { for (pos = 0; pos < dupl_ustr[test_num].res_buf_size/sizeof(WCHAR); pos++) { res_buf[pos] = dupl_ustr[test_num].res_buf[pos]; } res_str.Buffer = res_buf; } else { res_str.Buffer = NULL; } result = pRtlDuplicateUnicodeString(dupl_ustr[test_num].add_nul, &source_str, &dest_str); dest_ansi_str.Length = dest_str.Length / sizeof(WCHAR); dest_ansi_str.MaximumLength = dest_ansi_str.Length + 1; for (pos = 0; pos < dest_ansi_str.Length; pos++) { dest_ansi_buf[pos] = (char)dest_buf[pos]; } dest_ansi_buf[dest_ansi_str.Length] = '\0'; dest_ansi_str.Buffer = dest_ansi_buf; ok(result == dupl_ustr[test_num].result, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has result %x, expected %x\n", test_num, dupl_ustr[test_num].add_nul, result, dupl_ustr[test_num].result); ok(dest_str.Length == dupl_ustr[test_num].res_Length, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has Length %d, expected %d\n", test_num, dupl_ustr[test_num].add_nul, dest_str.Length, dupl_ustr[test_num].res_Length); ok(dest_str.MaximumLength == dupl_ustr[test_num].res_MaximumLength, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has MaximumLength %d, expected %d\n", test_num, dupl_ustr[test_num].add_nul, dest_str.MaximumLength, dupl_ustr[test_num].res_MaximumLength); if (result == STATUS_INVALID_PARAMETER) { ok((dest_str.Buffer == NULL && res_str.Buffer == NULL) || dest_str.Buffer == dest_buf, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination buffer changed %p expected %p\n", test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dest_buf); } else { ok(dest_str.Buffer != dest_buf, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination buffer unchanged %p\n", test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer); } if (dest_str.Buffer != NULL && dupl_ustr[test_num].res_buf != NULL) { ok(memcmp(dest_str.Buffer, res_str.Buffer, dupl_ustr[test_num].res_buf_size) == 0, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination \"%s\" expected \"%s\"\n", test_num, dupl_ustr[test_num].add_nul, dest_ansi_str.Buffer, dupl_ustr[test_num].res_buf); if(result == STATUS_SUCCESS) pRtlFreeUnicodeString(&dest_str); } else { ok(dest_str.Buffer == NULL && dupl_ustr[test_num].res_buf == NULL, "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination %p expected %p\n", test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dupl_ustr[test_num].res_buf); } } } static void test_RtlCopyString(void) { static const char teststring[] = "Some Wild String"; char deststring[] = " "; STRING str; STRING deststr; pRtlInitString(&str, teststring); pRtlInitString(&deststr, deststring); pRtlCopyString(&deststr, &str); ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied\n"); } 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; } ok(upper_ch == expected_upper_ch, "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]\n", ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch); } } 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; } 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\n"); } 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; } ok(upper_ch == expected_upper_ch, "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]\n", ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch); } } 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; } ascii_buf[i] = ch; result_buf[i] = '\0'; upper_buf[i] = upper_ch; } 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]\n", ascii_str.Buffer[i], ascii_str.Buffer[i], result_str.Buffer[i], result_str.Buffer[i], upper_str.Buffer[i], upper_str.Buffer[i]); } } static void test_RtlDowncaseUnicodeString(void) { int i; WCHAR ch; WCHAR lower_ch; WCHAR source_buf[1025]; WCHAR result_buf[1025]; WCHAR lower_buf[1025]; UNICODE_STRING source_str; UNICODE_STRING result_str; UNICODE_STRING lower_str; for (i = 0; i < 1024; i++) { ch = (WCHAR) i; if (ch >= 'A' && ch <= 'Z') { lower_ch = ch - 'A' + 'a'; } else if (ch >= 0xc0 && ch <= 0xde && ch != 0xd7) { lower_ch = ch + 0x20; } else if (ch >= 0x391 && ch <= 0x3ab && ch != 0x3a2) { lower_ch = ch + 0x20; } else { switch (ch) { case 0x178: lower_ch = 0xff; break; case 0x181: lower_ch = 0x253; break; case 0x186: lower_ch = 0x254; break; case 0x189: lower_ch = 0x256; break; case 0x18a: lower_ch = 0x257; break; case 0x18e: lower_ch = 0x1dd; break; case 0x18f: lower_ch = 0x259; break; case 0x190: lower_ch = 0x25b; break; case 0x193: lower_ch = 0x260; break; case 0x194: lower_ch = 0x263; break; case 0x196: lower_ch = 0x269; break; case 0x197: lower_ch = 0x268; break; case 0x19c: lower_ch = 0x26f; break; case 0x19d: lower_ch = 0x272; break; case 0x19f: lower_ch = 0x275; break; case 0x1a9: lower_ch = 0x283; break; case 0x1ae: lower_ch = 0x288; break; case 0x1b1: lower_ch = 0x28a; break; case 0x1b2: lower_ch = 0x28b; break; case 0x1b7: lower_ch = 0x292; break; case 0x1c4: lower_ch = 0x1c6; break; case 0x1c7: lower_ch = 0x1c9; break; case 0x1ca: lower_ch = 0x1cc; break; case 0x1f1: lower_ch = 0x1f3; break; case 0x386: lower_ch = 0x3ac; break; case 0x388: lower_ch = 0x3ad; break; case 0x389: lower_ch = 0x3ae; break; case 0x38a: lower_ch = 0x3af; break; case 0x38c: lower_ch = 0x3cc; break; case 0x38e: lower_ch = 0x3cd; break; case 0x38f: lower_ch = 0x3ce; break; default: lower_ch = ch; break; } /* switch */ } source_buf[i] = ch; result_buf[i] = '\0'; lower_buf[i] = lower_ch; } source_buf[i] = '\0'; result_buf[i] = '\0'; lower_buf[i] = '\0'; source_str.Length = 2048; source_str.MaximumLength = 2048; source_str.Buffer = source_buf; result_str.Length = 2048; result_str.MaximumLength = 2048; result_str.Buffer = result_buf; lower_str.Length = 2048; lower_str.MaximumLength = 2048; lower_str.Buffer = lower_buf; pRtlDowncaseUnicodeString(&result_str, &source_str, 0); for (i = 0; i <= 1024; i++) { ok(result_str.Buffer[i] == lower_str.Buffer[i] || result_str.Buffer[i] == source_str.Buffer[i] + 1, "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n", source_str.Buffer[i], source_str.Buffer[i], result_str.Buffer[i], result_str.Buffer[i], lower_str.Buffer[i], lower_str.Buffer[i]); } } typedef struct { int ansi_Length; int ansi_MaximumLength; int ansi_buf_size; const char *ansi_buf; int uni_Length; int uni_MaximumLength; int uni_buf_size; const char *uni_buf; BOOLEAN doalloc; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } ustr2astr_t; static const ustr2astr_t ustr2astr[] = { { 10, 12, 12, "------------", 0, 0, 0, "", TRUE, 0, 1, 1, "", STATUS_SUCCESS}, { 10, 12, 12, "------------", 12, 12, 12, "abcdef", TRUE, 6, 7, 7, "abcdef", STATUS_SUCCESS}, { 0, 2, 12, "------------", 12, 12, 12, "abcdef", TRUE, 6, 7, 7, "abcdef", STATUS_SUCCESS}, { 10, 12, 12, NULL, 12, 12, 12, "abcdef", TRUE, 6, 7, 7, "abcdef", STATUS_SUCCESS}, { 0, 0, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 0, 0, "", STATUS_BUFFER_OVERFLOW}, { 0, 1, 12, "------------", 12, 12, 12, "abcdef", FALSE, 0, 1, 1, "", STATUS_BUFFER_OVERFLOW}, { 0, 2, 12, "------------", 12, 12, 12, "abcdef", FALSE, 1, 2, 2, "a", STATUS_BUFFER_OVERFLOW}, { 0, 3, 12, "------------", 12, 12, 12, "abcdef", FALSE, 2, 3, 3, "ab", STATUS_BUFFER_OVERFLOW}, { 0, 5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd", STATUS_BUFFER_OVERFLOW}, { 8, 5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd", STATUS_BUFFER_OVERFLOW}, { 8, 6, 12, "------------", 12, 12, 12, "abcdef", FALSE, 5, 6, 6, "abcde", STATUS_BUFFER_OVERFLOW}, { 8, 7, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 7, 7, "abcdef", STATUS_SUCCESS}, { 8, 7, 12, "------------", 0, 12, 12, NULL, FALSE, 0, 7, 0, "", STATUS_SUCCESS}, #if 0 /* crashes on Japanese and Chinese XP */ { 0, 0, 12, NULL, 10, 10, 12, NULL, FALSE, 5, 0, 0, NULL, STATUS_BUFFER_OVERFLOW}, #endif }; static void test_RtlUnicodeStringToAnsiString(void) { size_t pos; CHAR ansi_buf[257]; WCHAR uni_buf[257]; STRING ansi_str; UNICODE_STRING uni_str; NTSTATUS result; unsigned int test_num; for (test_num = 0; test_num < ARRAY_SIZE(ustr2astr); test_num++) { ansi_str.Length = ustr2astr[test_num].ansi_Length; ansi_str.MaximumLength = ustr2astr[test_num].ansi_MaximumLength; if (ustr2astr[test_num].ansi_buf != NULL) { memcpy(ansi_buf, ustr2astr[test_num].ansi_buf, ustr2astr[test_num].ansi_buf_size); ansi_buf[ustr2astr[test_num].ansi_buf_size] = '\0'; ansi_str.Buffer = ansi_buf; } else { ansi_str.Buffer = NULL; } uni_str.Length = ustr2astr[test_num].uni_Length; uni_str.MaximumLength = ustr2astr[test_num].uni_MaximumLength; if (ustr2astr[test_num].uni_buf != NULL) { for (pos = 0; pos < ustr2astr[test_num].uni_buf_size/sizeof(WCHAR); pos++) { uni_buf[pos] = ustr2astr[test_num].uni_buf[pos]; } uni_str.Buffer = uni_buf; } else { uni_str.Buffer = NULL; } result = pRtlUnicodeStringToAnsiString(&ansi_str, &uni_str, ustr2astr[test_num].doalloc); ok(result == ustr2astr[test_num].result, "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has result %x, expected %x\n", test_num, ustr2astr[test_num].doalloc, result, ustr2astr[test_num].result); ok(ansi_str.Length == ustr2astr[test_num].res_Length, "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has Length %d, expected %d\n", test_num, ustr2astr[test_num].doalloc, ansi_str.Length, ustr2astr[test_num].res_Length); ok(ansi_str.MaximumLength == ustr2astr[test_num].res_MaximumLength, "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has MaximumLength %d, expected %d\n", test_num, ustr2astr[test_num].doalloc, ansi_str.MaximumLength, ustr2astr[test_num].res_MaximumLength); ok(memcmp(ansi_str.Buffer, ustr2astr[test_num].res_buf, ustr2astr[test_num].res_buf_size) == 0, "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has ansi \"%s\" expected \"%s\"\n", test_num, ustr2astr[test_num].doalloc, ansi_str.Buffer, ustr2astr[test_num].res_buf); if(result == STATUS_SUCCESS && ustr2astr[test_num].doalloc) pRtlFreeAnsiString(&ansi_str); } } typedef struct { int dest_Length; int dest_MaximumLength; int dest_buf_size; const char *dest_buf; const char *src; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } app_asc2str_t; static const app_asc2str_t app_asc2str[] = { { 5, 12, 15, "TestS01234abcde", "tring", 10, 12, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 11, 15, "TestS01234abcde", "tring", 10, 11, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 10, 15, "TestS01234abcde", "tring", 10, 10, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 9, 15, "TestS01234abcde", "tring", 5, 9, 15, "TestS01234abcde", STATUS_BUFFER_TOO_SMALL}, { 5, 0, 15, "TestS01234abcde", "tring", 5, 0, 15, "TestS01234abcde", STATUS_BUFFER_TOO_SMALL}, { 5, 14, 15, "TestS01234abcde", "tring", 10, 14, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 14, 15, "TestS01234abcde", NULL, 5, 14, 15, "TestS01234abcde", STATUS_SUCCESS}, { 5, 14, 15, NULL, NULL, 5, 14, 15, NULL, STATUS_SUCCESS}, { 5, 12, 15, "Tst\0S01234abcde", "tr\0i", 7, 12, 15, "Tst\0Str234abcde", STATUS_SUCCESS}, }; static void test_RtlAppendAsciizToString(void) { CHAR dest_buf[257]; STRING dest_str; NTSTATUS result; unsigned int test_num; for (test_num = 0; test_num < ARRAY_SIZE(app_asc2str); test_num++) { dest_str.Length = app_asc2str[test_num].dest_Length; dest_str.MaximumLength = app_asc2str[test_num].dest_MaximumLength; if (app_asc2str[test_num].dest_buf != NULL) { memcpy(dest_buf, app_asc2str[test_num].dest_buf, app_asc2str[test_num].dest_buf_size); dest_buf[app_asc2str[test_num].dest_buf_size] = '\0'; dest_str.Buffer = dest_buf; } else { dest_str.Buffer = NULL; } result = pRtlAppendAsciizToString(&dest_str, app_asc2str[test_num].src); ok(result == app_asc2str[test_num].result, "(test %d): RtlAppendAsciizToString(dest, src) has result %x, expected %x\n", test_num, result, app_asc2str[test_num].result); ok(dest_str.Length == app_asc2str[test_num].res_Length, "(test %d): RtlAppendAsciizToString(dest, src) dest has Length %d, expected %d\n", test_num, dest_str.Length, app_asc2str[test_num].res_Length); ok(dest_str.MaximumLength == app_asc2str[test_num].res_MaximumLength, "(test %d): RtlAppendAsciizToString(dest, src) dest has MaximumLength %d, expected %d\n", test_num, dest_str.MaximumLength, app_asc2str[test_num].res_MaximumLength); if (dest_str.Buffer == dest_buf) { ok(memcmp(dest_buf, app_asc2str[test_num].res_buf, app_asc2str[test_num].res_buf_size) == 0, "(test %d): RtlAppendAsciizToString(dest, src) has dest \"%s\" expected \"%s\"\n", test_num, dest_buf, app_asc2str[test_num].res_buf); } else { ok(dest_str.Buffer == app_asc2str[test_num].res_buf, "(test %d): RtlAppendAsciizToString(dest, src) dest has Buffer %p expected %p\n", test_num, dest_str.Buffer, app_asc2str[test_num].res_buf); } } } typedef struct { int dest_Length; int dest_MaximumLength; int dest_buf_size; const char *dest_buf; int src_Length; int src_MaximumLength; int src_buf_size; const char *src_buf; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } app_str2str_t; static const app_str2str_t app_str2str[] = { { 5, 12, 15, "TestS01234abcde", 5, 5, 7, "tringZY", 10, 12, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 11, 15, "TestS01234abcde", 5, 5, 7, "tringZY", 10, 11, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 10, 15, "TestS01234abcde", 5, 5, 7, "tringZY", 10, 10, 15, "TestStringabcde", STATUS_SUCCESS}, { 5, 9, 15, "TestS01234abcde", 5, 5, 7, "tringZY", 5, 9, 15, "TestS01234abcde", STATUS_BUFFER_TOO_SMALL}, { 5, 0, 15, "TestS01234abcde", 0, 0, 7, "tringZY", 5, 0, 15, "TestS01234abcde", STATUS_SUCCESS}, { 5, 14, 15, "TestS01234abcde", 0, 0, 7, "tringZY", 5, 14, 15, "TestS01234abcde", STATUS_SUCCESS}, { 5, 14, 15, "TestS01234abcde", 0, 0, 7, NULL, 5, 14, 15, "TestS01234abcde", STATUS_SUCCESS}, { 5, 14, 15, NULL, 0, 0, 7, NULL, 5, 14, 15, NULL, STATUS_SUCCESS}, { 5, 12, 15, "Tst\0S01234abcde", 4, 4, 7, "tr\0iZY", 9, 12, 15, "Tst\0Str\0i4abcde", STATUS_SUCCESS}, }; static void test_RtlAppendStringToString(void) { CHAR dest_buf[257]; CHAR src_buf[257]; STRING dest_str; STRING src_str; NTSTATUS result; unsigned int test_num; for (test_num = 0; test_num < ARRAY_SIZE(app_str2str); test_num++) { dest_str.Length = app_str2str[test_num].dest_Length; dest_str.MaximumLength = app_str2str[test_num].dest_MaximumLength; if (app_str2str[test_num].dest_buf != NULL) { memcpy(dest_buf, app_str2str[test_num].dest_buf, app_str2str[test_num].dest_buf_size); dest_buf[app_str2str[test_num].dest_buf_size] = '\0'; dest_str.Buffer = dest_buf; } else { dest_str.Buffer = NULL; } src_str.Length = app_str2str[test_num].src_Length; src_str.MaximumLength = app_str2str[test_num].src_MaximumLength; if (app_str2str[test_num].src_buf != NULL) { memcpy(src_buf, app_str2str[test_num].src_buf, app_str2str[test_num].src_buf_size); src_buf[app_str2str[test_num].src_buf_size] = '\0'; src_str.Buffer = src_buf; } else { src_str.Buffer = NULL; } result = pRtlAppendStringToString(&dest_str, &src_str); ok(result == app_str2str[test_num].result, "(test %d): RtlAppendStringToString(dest, src) has result %x, expected %x\n", test_num, result, app_str2str[test_num].result); ok(dest_str.Length == app_str2str[test_num].res_Length, "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n", test_num, dest_str.Length, app_str2str[test_num].res_Length); ok(dest_str.MaximumLength == app_str2str[test_num].res_MaximumLength, "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n", test_num, dest_str.MaximumLength, app_str2str[test_num].res_MaximumLength); if (dest_str.Buffer == dest_buf) { ok(memcmp(dest_buf, app_str2str[test_num].res_buf, app_str2str[test_num].res_buf_size) == 0, "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n", test_num, dest_buf, app_str2str[test_num].res_buf); } else { ok(dest_str.Buffer == app_str2str[test_num].res_buf, "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n", test_num, dest_str.Buffer, app_str2str[test_num].res_buf); } } } typedef struct { int dest_Length; int dest_MaximumLength; int dest_buf_size; const char *dest_buf; const char *src; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } app_uni2str_t; static const app_uni2str_t app_uni2str[] = { { 4, 12, 14, "Fake0123abcdef", "Ustr\0", 8, 12, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, { 4, 11, 14, "Fake0123abcdef", "Ustr\0", 8, 11, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, { 4, 10, 14, "Fake0123abcdef", "Ustr\0", 8, 10, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, /* In the following test the native function writes beyond MaximumLength * { 4, 9, 14, "Fake0123abcdef", "Ustr\0", 8, 9, 14, "FakeUstrabcdef", STATUS_SUCCESS}, */ { 4, 8, 14, "Fake0123abcdef", "Ustr\0", 8, 8, 14, "FakeUstrabcdef", STATUS_SUCCESS}, { 4, 7, 14, "Fake0123abcdef", "Ustr\0", 4, 7, 14, "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL}, { 4, 0, 14, "Fake0123abcdef", "Ustr\0", 4, 0, 14, "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL}, { 4, 14, 14, "Fake0123abcdef", "Ustr\0", 8, 14, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, { 4, 14, 14, "Fake0123abcdef", NULL, 4, 14, 14, "Fake0123abcdef", STATUS_SUCCESS}, { 4, 14, 14, NULL, NULL, 4, 14, 14, NULL, STATUS_SUCCESS}, { 4, 14, 14, "Fake0123abcdef", "U\0stri\0", 10, 14, 14, "FakeU\0stri\0\0ef", STATUS_SUCCESS}, { 6, 14, 16, "Te\0\0stabcdefghij", "St\0\0ri", 8, 14, 16, "Te\0\0stSt\0\0efghij", STATUS_SUCCESS}, }; static void test_RtlAppendUnicodeToString(void) { WCHAR dest_buf[257]; UNICODE_STRING dest_str; NTSTATUS result; unsigned int test_num; for (test_num = 0; test_num < ARRAY_SIZE(app_uni2str); test_num++) { dest_str.Length = app_uni2str[test_num].dest_Length; dest_str.MaximumLength = app_uni2str[test_num].dest_MaximumLength; if (app_uni2str[test_num].dest_buf != NULL) { memcpy(dest_buf, app_uni2str[test_num].dest_buf, app_uni2str[test_num].dest_buf_size); dest_buf[app_uni2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0'; dest_str.Buffer = dest_buf; } else { dest_str.Buffer = NULL; } result = pRtlAppendUnicodeToString(&dest_str, (LPCWSTR) app_uni2str[test_num].src); ok(result == app_uni2str[test_num].result, "(test %d): RtlAppendUnicodeToString(dest, src) has result %x, expected %x\n", test_num, result, app_uni2str[test_num].result); ok(dest_str.Length == app_uni2str[test_num].res_Length, "(test %d): RtlAppendUnicodeToString(dest, src) dest has Length %d, expected %d\n", test_num, dest_str.Length, app_uni2str[test_num].res_Length); ok(dest_str.MaximumLength == app_uni2str[test_num].res_MaximumLength, "(test %d): RtlAppendUnicodeToString(dest, src) dest has MaximumLength %d, expected %d\n", test_num, dest_str.MaximumLength, app_uni2str[test_num].res_MaximumLength); if (dest_str.Buffer == dest_buf) { ok(memcmp(dest_buf, app_uni2str[test_num].res_buf, app_uni2str[test_num].res_buf_size) == 0, "(test %d): RtlAppendUnicodeToString(dest, src) has dest \"%s\" expected \"%s\"\n", test_num, (char *) dest_buf, app_uni2str[test_num].res_buf); } else { ok(dest_str.Buffer == (WCHAR *) app_uni2str[test_num].res_buf, "(test %d): RtlAppendUnicodeToString(dest, src) dest has Buffer %p expected %p\n", test_num, dest_str.Buffer, app_uni2str[test_num].res_buf); } } } typedef struct { int dest_Length; int dest_MaximumLength; int dest_buf_size; const char *dest_buf; int src_Length; int src_MaximumLength; int src_buf_size; const char *src_buf; int res_Length; int res_MaximumLength; int res_buf_size; const char *res_buf; NTSTATUS result; } app_ustr2str_t; static const app_ustr2str_t app_ustr2str[] = { { 4, 12, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 12, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, { 4, 11, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 11, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, { 4, 10, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 10, 14, "FakeUstr\0\0cdef", STATUS_SUCCESS}, /* In the following test the native function writes beyond MaximumLength * { 4, 9, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 9, 14, "FakeUstrabcdef", STATUS_SUCCESS}, */ { 4, 8, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 8, 8, 14, "FakeUstrabcdef", STATUS_SUCCESS}, { 4, 7, 14, "Fake0123abcdef", 4, 6, 8, "UstrZYXW", 4, 7, 14, "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL}, { 4, 0, 14, "Fake0123abcdef", 0, 0, 8, "UstrZYXW", 4, 0, 14, "Fake0123abcdef", STATUS_SUCCESS}, { 4, 14, 14, "Fake0123abcdef", 0, 0, 8, "UstrZYXW", 4, 14, 14, "Fake0123abcdef", STATUS_SUCCESS}, { 4, 14, 14, "Fake0123abcdef", 0, 0, 8, NULL, 4, 14, 14, "Fake0123abcdef", STATUS_SUCCESS}, { 4, 14, 14, NULL, 0, 0, 8, NULL, 4, 14, 14, NULL, STATUS_SUCCESS}, { 6, 14, 16, "Te\0\0stabcdefghij", 6, 8, 8, "St\0\0riZY", 12, 14, 16, "Te\0\0stSt\0\0ri\0\0ij", STATUS_SUCCESS}, }; static void test_RtlAppendUnicodeStringToString(void) { WCHAR dest_buf[257]; WCHAR src_buf[257]; UNICODE_STRING dest_str; UNICODE_STRING src_str; NTSTATUS result; unsigned int test_num; for (test_num = 0; test_num < ARRAY_SIZE(app_ustr2str); test_num++) { dest_str.Length = app_ustr2str[test_num].dest_Length; dest_str.MaximumLength = app_ustr2str[test_num].dest_MaximumLength; if (app_ustr2str[test_num].dest_buf != NULL) { memcpy(dest_buf, app_ustr2str[test_num].dest_buf, app_ustr2str[test_num].dest_buf_size); dest_buf[app_ustr2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0'; dest_str.Buffer = dest_buf; } else { dest_str.Buffer = NULL; } src_str.Length = app_ustr2str[test_num].src_Length; src_str.MaximumLength = app_ustr2str[test_num].src_MaximumLength; if (app_ustr2str[test_num].src_buf != NULL) { memcpy(src_buf, app_ustr2str[test_num].src_buf, app_ustr2str[test_num].src_buf_size); src_buf[app_ustr2str[test_num].src_buf_size/sizeof(WCHAR)] = '\0'; src_str.Buffer = src_buf; } else { src_str.Buffer = NULL; } result = pRtlAppendUnicodeStringToString(&dest_str, &src_str); ok(result == app_ustr2str[test_num].result, "(test %d): RtlAppendStringToString(dest, src) has result %x, expected %x\n", test_num, result, app_ustr2str[test_num].result); ok(dest_str.Length == app_ustr2str[test_num].res_Length, "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n", test_num, dest_str.Length, app_ustr2str[test_num].res_Length); ok(dest_str.MaximumLength == app_ustr2str[test_num].res_MaximumLength, "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n", test_num, dest_str.MaximumLength, app_ustr2str[test_num].res_MaximumLength); if (dest_str.Buffer == dest_buf) { ok(memcmp(dest_buf, app_ustr2str[test_num].res_buf, app_ustr2str[test_num].res_buf_size) == 0, "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n", test_num, (char *) dest_buf, app_ustr2str[test_num].res_buf); } else { ok(dest_str.Buffer == (WCHAR *) app_ustr2str[test_num].res_buf, "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n", test_num, dest_str.Buffer, app_ustr2str[test_num].res_buf); } } } typedef struct { int flags; const char *main_str; const char *search_chars; USHORT pos; NTSTATUS result; } find_ch_in_ustr_t; static const find_ch_in_ustr_t find_ch_in_ustr[] = { { 0, "Some Wild String", "S", 2, STATUS_SUCCESS}, { 0, "This is a String", "String", 6, STATUS_SUCCESS}, { 1, "This is a String", "String", 30, STATUS_SUCCESS}, { 2, "This is a String", "String", 2, STATUS_SUCCESS}, { 3, "This is a String", "String", 18, STATUS_SUCCESS}, { 0, "This is a String", "Wild", 6, STATUS_SUCCESS}, { 1, "This is a String", "Wild", 26, STATUS_SUCCESS}, { 2, "This is a String", "Wild", 2, STATUS_SUCCESS}, { 3, "This is a String", "Wild", 30, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "", 0, STATUS_NOT_FOUND}, { 0, "abcdefghijklmnopqrstuvwxyz", "123", 0, STATUS_NOT_FOUND}, { 0, "abcdefghijklmnopqrstuvwxyz", "a", 2, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "12a34", 2, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "12b34", 4, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "12y34", 50, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "12z34", 52, STATUS_SUCCESS}, { 0, "abcdefghijklmnopqrstuvwxyz", "rvz", 36, STATUS_SUCCESS}, { 0, "abcdefghijklmmlkjihgfedcba", "egik", 10, STATUS_SUCCESS}, { 1, "abcdefghijklmnopqrstuvwxyz", "", 0, STATUS_NOT_FOUND}, { 1, "abcdefghijklmnopqrstuvwxyz", "rvz", 50, STATUS_SUCCESS}, { 1, "abcdefghijklmnopqrstuvwxyz", "ravy", 48, STATUS_SUCCESS}, { 1, "abcdefghijklmnopqrstuvwxyz", "raxv", 46, STATUS_SUCCESS}, { 2, "abcdefghijklmnopqrstuvwxyz", "", 2, STATUS_SUCCESS}, { 2, "abcdefghijklmnopqrstuvwxyz", "rvz", 2, STATUS_SUCCESS}, { 2, "abcdefghijklmnopqrstuvwxyz", "vaz", 4, STATUS_SUCCESS}, { 2, "abcdefghijklmnopqrstuvwxyz", "ravbz", 6, STATUS_SUCCESS}, { 3, "abcdefghijklmnopqrstuvwxyz", "", 50, STATUS_SUCCESS}, { 3, "abcdefghijklmnopqrstuvwxyz", "123", 50, STATUS_SUCCESS}, { 3, "abcdefghijklmnopqrstuvwxyz", "ahp", 50, STATUS_SUCCESS}, { 3, "abcdefghijklmnopqrstuvwxyz", "rvz", 48, STATUS_SUCCESS}, { 0, NULL, "abc", 0, STATUS_NOT_FOUND}, { 1, NULL, "abc", 0, STATUS_NOT_FOUND}, { 2, NULL, "abc", 0, STATUS_NOT_FOUND}, { 3, NULL, "abc", 0, STATUS_NOT_FOUND}, { 0, "abcdefghijklmnopqrstuvwxyz", NULL, 0, STATUS_NOT_FOUND}, { 1, "abcdefghijklmnopqrstuvwxyz", NULL, 0, STATUS_NOT_FOUND}, { 2, "abcdefghijklmnopqrstuvwxyz", NULL, 2, STATUS_SUCCESS}, { 3, "abcdefghijklmnopqrstuvwxyz", NULL, 50, STATUS_SUCCESS}, { 0, NULL, NULL, 0, STATUS_NOT_FOUND}, { 1, NULL, NULL, 0, STATUS_NOT_FOUND}, { 2, NULL, NULL, 0, STATUS_NOT_FOUND}, { 3, NULL, NULL, 0, STATUS_NOT_FOUND}, { 0, "abcdabcdabcdabcdabcdabcd", "abcd", 2, STATUS_SUCCESS}, { 1, "abcdabcdabcdabcdabcdabcd", "abcd", 46, STATUS_SUCCESS}, { 2, "abcdabcdabcdabcdabcdabcd", "abcd", 0, STATUS_NOT_FOUND}, { 3, "abcdabcdabcdabcdabcdabcd", "abcd", 0, STATUS_NOT_FOUND}, }; static void test_RtlFindCharInUnicodeString(void) { WCHAR main_str_buf[257]; WCHAR search_chars_buf[257]; UNICODE_STRING main_str; UNICODE_STRING search_chars; USHORT pos; NTSTATUS result; unsigned int idx; unsigned int test_num; if (!pRtlFindCharInUnicodeString) { win_skip("RtlFindCharInUnicodeString is not available\n"); return; } for (test_num = 0; test_num < ARRAY_SIZE(find_ch_in_ustr); test_num++) { if (find_ch_in_ustr[test_num].main_str != NULL) { main_str.Length = strlen(find_ch_in_ustr[test_num].main_str) * sizeof(WCHAR); main_str.MaximumLength = main_str.Length + sizeof(WCHAR); for (idx = 0; idx < main_str.Length / sizeof(WCHAR); idx++) { main_str_buf[idx] = find_ch_in_ustr[test_num].main_str[idx]; } main_str.Buffer = main_str_buf; } else { main_str.Length = 0; main_str.MaximumLength = 0; main_str.Buffer = NULL; } if (find_ch_in_ustr[test_num].search_chars != NULL) { search_chars.Length = strlen(find_ch_in_ustr[test_num].search_chars) * sizeof(WCHAR); search_chars.MaximumLength = search_chars.Length + sizeof(WCHAR); for (idx = 0; idx < search_chars.Length / sizeof(WCHAR); idx++) { search_chars_buf[idx] = find_ch_in_ustr[test_num].search_chars[idx]; } search_chars.Buffer = search_chars_buf; } else { search_chars.Length = 0; search_chars.MaximumLength = 0; search_chars.Buffer = NULL; } pos = 12345; result = pRtlFindCharInUnicodeString(find_ch_in_ustr[test_num].flags, &main_str, &search_chars, &pos); ok(result == find_ch_in_ustr[test_num].result, "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) has result %x, expected %x\n", test_num, find_ch_in_ustr[test_num].flags, find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars, result, find_ch_in_ustr[test_num].result); ok(pos == find_ch_in_ustr[test_num].pos, "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) assigns %d to pos, expected %d\n", test_num, find_ch_in_ustr[test_num].flags, find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars, pos, find_ch_in_ustr[test_num].pos); } } typedef struct { int base; const char *str; int value; NTSTATUS result, alternative; } str2int_t; 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, "\001\002\003\00411", 11, STATUS_SUCCESS}, /* whitespace char 1 to 4 */ { 0, "\005\006\007\01012", 12, STATUS_SUCCESS}, /* whitespace char 5 to 8 */ { 0, "\011\012\013\01413", 13, STATUS_SUCCESS}, /* whitespace char 9 to 12 */ { 0, "\015\016\017\02014", 14, STATUS_SUCCESS}, /* whitespace char 13 to 16 */ { 0, "\021\022\023\02415", 15, STATUS_SUCCESS}, /* whitespace char 17 to 20 */ { 0, "\025\026\027\03016", 16, STATUS_SUCCESS}, /* whitespace char 21 to 24 */ { 0, "\031\032\033\03417", 17, STATUS_SUCCESS}, /* whitespace char 25 to 28 */ { 0, "\035\036\037\04018", 18, STATUS_SUCCESS}, /* whitespace char 29 to 32 */ { 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}, /* explicit 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", 19088896, 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, STATUS_INVALID_PARAMETER}, /* 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, STATUS_INVALID_PARAMETER}, /* 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, STATUS_INVALID_PARAMETER}, /* 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 although base is 10 */ {10, "", 0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* 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, STATUS_INVALID_PARAMETER}, /* empty string */ {20, "0", 0, STATUS_INVALID_PARAMETER}, /* illegal base */ {-8, "0", 0, STATUS_INVALID_PARAMETER}, /* Negative base */ /* { 0, NULL, 0, STATUS_SUCCESS}, */ /* NULL as string */ }; static void test_RtlUnicodeStringToInteger(void) { unsigned int test_num; int value; NTSTATUS result; WCHAR *wstr; UNICODE_STRING uni; for (test_num = 0; test_num < ARRAY_SIZE(str2int); test_num++) { wstr = AtoW(str2int[test_num].str); value = 0xdeadbeef; pRtlInitUnicodeString(&uni, wstr); result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value); ok(result == str2int[test_num].result || (str2int[test_num].alternative && result == str2int[test_num].alternative), "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n", test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result, str2int[test_num].alternative); if (result == STATUS_SUCCESS) ok(value == str2int[test_num].value || broken(str2int[test_num].str[0] == '\0' && str2int[test_num].base == 16), /* nt4 */ "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n", test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value); else ok(value == 0xdeadbeef || value == 0 /* vista */, "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n", test_num, str2int[test_num].str, str2int[test_num].base, value); HeapFree(GetProcessHeap(), 0, wstr); } 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 %x\n", str2int[1].str, str2int[1].base, result); result = pRtlUnicodeStringToInteger(&uni, 20, NULL); ok(result == STATUS_INVALID_PARAMETER || result == STATUS_ACCESS_VIOLATION, "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %x\n", 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 %x\n", str2int[1].base, result); ok(value == 12345, "didn't return expected value (test a): expected: %d, got: %d\n", 12345, value); uni.Length = 5; /* Use odd Length (2.5 WCHARS) */ result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value); ok(result == STATUS_SUCCESS || result == STATUS_INVALID_PARAMETER /* vista */, "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %x\n", str2int[1].base, result); if (result == STATUS_SUCCESS) ok(value == 12, "didn't return expected value (test b): expected: %d, got: %d\n", 12, value); uni.Length = 2; result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value); ok(result == STATUS_SUCCESS, "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %x\n", str2int[1].base, result); ok(value == 1, "didn't return expected value (test c): expected: %d, got: %d\n", 1, value); /* w2k: uni.Length = 0 returns value 11234567 instead of 0 */ HeapFree(GetProcessHeap(), 0, wstr); } static void test_RtlCharToInteger(void) { unsigned int test_num; int value; NTSTATUS result; for (test_num = 0; test_num < ARRAY_SIZE(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 || (str2int[test_num].alternative && result == str2int[test_num].alternative), "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n", test_num, str2int[test_num].str, str2int[test_num].base, result, str2int[test_num].result, str2int[test_num].alternative); if (result == STATUS_SUCCESS) ok(value == str2int[test_num].value, "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n", test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value); else ok(value == 0 || value == 0xdeadbeef, "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n", test_num, str2int[test_num].str, str2int[test_num].base, value); } } result = pRtlCharToInteger(str2int[1].str, str2int[1].base, NULL); ok(result == STATUS_ACCESS_VIOLATION, "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %x\n", 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 %x\n", str2int[1].str, result); } #define STRI_BUFFER_LENGTH 35 typedef struct { int base; ULONG value; USHORT Length; USHORT MaximumLength; const 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}, broken on windows */ /* { 2, 65535, 16, 33, "1111111111111111\0------------------", STATUS_SUCCESS}, broken on windows */ { 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}, broken on windows */ /* { 2, 32768, 16, 16, "1000000000000000-------------------", STATUS_SUCCESS}, broken on windows */ { 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 */ }; 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]; } 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] = '-'; } 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] = '-'; } /* 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 triggered when testing native */ expected_unicode_string.Length = 0; } } else { ok(result == int2str->result, "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) has result %x, expected: %x\n", 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(%u, %d, [out]) string \"%s\" is not NULL terminated\n", test_num, int2str->value, int2str->base, ansi_str.Buffer); } } ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0, "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) assigns string \"%s\", expected: \"%s\"\n", test_num, int2str->value, int2str->base, ansi_str.Buffer, expected_ansi_str.Buffer); ok(unicode_string.Length == expected_unicode_string.Length, "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) string has Length %d, expected: %d\n", test_num, int2str->value, int2str->base, unicode_string.Length, expected_unicode_string.Length); ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength, "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) string has MaximumLength %d, expected: %d\n", 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) { size_t test_num; for (test_num = 0; test_num < ARRAY_SIZE(int2str); test_num++) one_RtlIntegerToUnicodeString_test(test_num, &int2str[test_num]); } 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(%u, %d, %d, [out]) has result %x, expected: %x\n", test_num, int2str->value, int2str->base, int2str->MaximumLength, result, int2str->result); ok(memcmp(dest_str, int2str->Buffer, STRI_BUFFER_LENGTH) == 0, "(test %d): RtlIntegerToChar(%u, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n", test_num, int2str->value, int2str->base, int2str->MaximumLength, dest_str, int2str->Buffer); } static void test_RtlIntegerToChar(void) { NTSTATUS result; size_t test_num; for (test_num = 0; test_num < ARRAY_SIZE(int2str); test_num++) one_RtlIntegerToChar_test(test_num, &int2str[test_num]); result = pRtlIntegerToChar(int2str[0].value, 20, int2str[0].MaximumLength, NULL); ok(result == STATUS_INVALID_PARAMETER, "(test a): RtlIntegerToChar(%u, %d, %d, NULL) has result %x, expected: %x\n", 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(%u, %d, %d, NULL) has result %x, expected: %x\n", 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(%u, %d, %d, NULL) has result %x, expected: %x\n", 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(%u, %d, %d, NULL) has result %x, expected: %x\n", int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION); } static void test_RtlIsTextUnicode(void) { char ascii[] = "A simple string"; char false_positive[] = {0x41, 0x0a, 0x0d, 0x1d}; WCHAR false_negative = 0x0d0a; WCHAR unicode[] = {'A',' ','U','n','i','c','o','d','e',' ','s','t','r','i','n','g',0}; WCHAR unicode_no_controls[] = {'A','U','n','i','c','o','d','e','s','t','r','i','n','g',0}; /* String with both byte-reversed and standard Unicode control characters. */ WCHAR mixed_controls[] = {'\t',0x9000,0x0d00,'\n',0}; WCHAR *be_unicode; WCHAR *be_unicode_no_controls; BOOLEAN res; int flags; int i; if (!pRtlIsTextUnicode) { win_skip("RtlIsTextUnicode is not available\n"); return; } ok(!pRtlIsTextUnicode(ascii, sizeof(ascii), NULL), "ASCII text detected as Unicode\n"); res = pRtlIsTextUnicode(unicode, sizeof(unicode), NULL); ok(res || broken(res == FALSE), /* NT4 */ "Text should be Unicode\n"); ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, NULL), "Text should be Unicode\n"); flags = IS_TEXT_UNICODE_UNICODE_MASK; ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass a Unicode\n"); ok(flags == (IS_TEXT_UNICODE_STATISTICS | IS_TEXT_UNICODE_CONTROLS), "Expected flags 0x6, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_MASK; ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass reverse Unicode tests\n"); ok(flags == 0, "Expected flags 0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_ODD_LENGTH; ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, &flags), "Odd length test should have passed\n"); ok(flags == IS_TEXT_UNICODE_ODD_LENGTH, "Expected flags 0x200, obtained %x\n", flags); be_unicode = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR)); be_unicode[0] = 0xfffe; for (i = 0; i < ARRAY_SIZE(unicode); i++) { be_unicode[i + 1] = (unicode[i] >> 8) | ((unicode[i] & 0xff) << 8); } ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, NULL), "Reverse endian should not be Unicode\n"); ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), NULL), "Reverse endian should not be Unicode\n"); flags = IS_TEXT_UNICODE_REVERSE_MASK; ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), &flags), "Reverse endian should be Unicode\n"); todo_wine ok(flags == (IS_TEXT_UNICODE_REVERSE_ASCII16 | IS_TEXT_UNICODE_REVERSE_STATISTICS | IS_TEXT_UNICODE_REVERSE_CONTROLS), "Expected flags 0x70, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_MASK; ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags), "Reverse endian should be Unicode\n"); ok(flags == (IS_TEXT_UNICODE_REVERSE_CONTROLS | IS_TEXT_UNICODE_REVERSE_SIGNATURE), "Expected flags 0xc0, obtained %x\n", flags); /* build byte reversed unicode string with no control chars */ be_unicode_no_controls = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR)); ok(be_unicode_no_controls != NULL, "Expected HeapAlloc to succeed.\n"); be_unicode_no_controls[0] = 0xfffe; for (i = 0; i < ARRAY_SIZE(unicode_no_controls); i++) be_unicode_no_controls[i + 1] = (unicode_no_controls[i] >> 8) | ((unicode_no_controls[i] & 0xff) << 8); /* The following tests verify that the tests for */ /* IS_TEXT_UNICODE_CONTROLS and IS_TEXT_UNICODE_REVERSE_CONTROLS */ /* are not mutually exclusive. Regardless of whether the strings */ /* contain an indication of endianness, the tests are still */ /* run if the flag is passed to (Rtl)IsTextUnicode. */ /* Test IS_TEXT_UNICODE_CONTROLS flag */ flags = IS_TEXT_UNICODE_CONTROLS; ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_CONTROLS; ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on byte-reversed Unicode string lacking control characters.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_CONTROLS; ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should pass on Unicode string lacking control characters.\n"); ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags); flags = IS_TEXT_UNICODE_CONTROLS; ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls) + 2, &flags), "Test should not pass with standard Unicode string.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_CONTROLS; ok(pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing control characters.\n"); ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags); /* Test IS_TEXT_UNICODE_REVERSE_CONTROLS flag */ flags = IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should not pass on Unicode string lacking control characters.\n"); ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags), "Test should pass with byte-reversed Unicode string containing control characters.\n"); ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags); flags = IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing byte-reversed control characters.\n"); ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags); /* Test with flags for both byte-reverse and standard Unicode characters */ flags = IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS; ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on string containing both byte-reversed and standard control characters.\n"); ok(flags == (IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS), "Expected flags 0x44, obtained %x\n", flags); flags = IS_TEXT_UNICODE_STATISTICS; todo_wine ok(pRtlIsTextUnicode(false_positive, sizeof(false_positive), &flags), "Test should pass on false positive.\n"); ok(!pRtlIsTextUnicode(&false_negative, sizeof(false_negative), NULL), "Test should fail on 0x0d0a (MALAYALAM LETTER UU).\n"); HeapFree(GetProcessHeap(), 0, be_unicode); HeapFree(GetProcessHeap(), 0, be_unicode_no_controls); } static void test_RtlCompareUnicodeString(void) { WCHAR ch1, ch2; UNICODE_STRING str1, str2; str1.Buffer = &ch1; str1.Length = str1.MaximumLength = sizeof(WCHAR); str2.Buffer = &ch2; str2.Length = str2.MaximumLength = sizeof(WCHAR); for (ch1 = 0; ch1 < 512; ch1++) { for (ch2 = 0; ch2 < 1024; ch2++) { LONG res = pRtlCompareUnicodeString( &str1, &str2, FALSE ); ok( res == (ch1 - ch2), "wrong result %d %04x %04x\n", res, ch1, ch2 ); res = pRtlCompareUnicodeString( &str1, &str2, TRUE ); ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)), "wrong result %d %04x %04x\n", res, ch1, ch2 ); if (pRtlCompareUnicodeStrings) { res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, FALSE ); ok( res == (ch1 - ch2), "wrong result %d %04x %04x\n", res, ch1, ch2 ); res = pRtlCompareUnicodeStrings( &ch1, 1, &ch2, 1, TRUE ); ok( res == (pRtlUpcaseUnicodeChar(ch1) - pRtlUpcaseUnicodeChar(ch2)), "wrong result %d %04x %04x\n", res, ch1, ch2 ); } } } } static const WCHAR szGuid[] = { '{','0','1','0','2','0','3','0','4','-', '0','5','0','6','-' ,'0','7','0','8','-','0','9','0','A','-', '0','B','0','C','0','D','0','E','0','F','0','A','}','\0' }; static const WCHAR szGuid2[] = { '{','0','1','0','2','0','3','0','4','-', '0','5','0','6','-' ,'0','7','0','8','-','0','9','0','A','-', '0','B','0','C','0','D','0','E','0','F','0','A',']','\0' }; DEFINE_GUID(IID_Endianness, 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0A); static void test_RtlGUIDFromString(void) { GUID guid; UNICODE_STRING str; NTSTATUS ret; if (!pRtlGUIDFromString) { win_skip("RtlGUIDFromString is not available\n"); return; } str.Length = str.MaximumLength = sizeof(szGuid) - sizeof(WCHAR); str.Buffer = (LPWSTR)szGuid; ret = pRtlGUIDFromString(&str, &guid); ok(ret == 0, "expected ret=0, got 0x%0x\n", ret); ok(IsEqualGUID(&guid, &IID_Endianness), "Endianness broken\n"); str.Length = str.MaximumLength = sizeof(szGuid2) - sizeof(WCHAR); str.Buffer = (LPWSTR)szGuid2; ret = pRtlGUIDFromString(&str, &guid); ok(ret, "expected ret!=0\n"); } static void test_RtlStringFromGUID(void) { UNICODE_STRING str; NTSTATUS ret; if (!pRtlStringFromGUID) { win_skip("RtlStringFromGUID is not available\n"); return; } str.Length = str.MaximumLength = 0; str.Buffer = NULL; ret = pRtlStringFromGUID(&IID_Endianness, &str); ok(ret == 0, "expected ret=0, got 0x%0x\n", ret); ok(str.Buffer && !lstrcmpiW(str.Buffer, szGuid), "Endianness broken\n"); pRtlFreeUnicodeString(&str); } struct hash_unicodestring_test { WCHAR str[50]; BOOLEAN case_insensitive; ULONG hash; }; static const struct hash_unicodestring_test hash_test[] = { { {'T',0}, FALSE, 0x00000054 }, { {'T','e','s','t',0}, FALSE, 0x766bb952 }, { {'T','e','S','t',0}, FALSE, 0x764bb172 }, { {'t','e','s','t',0}, FALSE, 0x4745d132 }, { {'t','e','s','t',0}, TRUE, 0x6689c132 }, { {'T','E','S','T',0}, TRUE, 0x6689c132 }, { {'T','E','S','T',0}, FALSE, 0x6689c132 }, { {'a','b','c','d','e','f',0}, FALSE, 0x971318c3 }, { { 0 } } }; static void test_RtlHashUnicodeString(void) { static const WCHAR strW[] = {'T','e','s','t',0,'1',0}; const struct hash_unicodestring_test *ptr; UNICODE_STRING str; NTSTATUS status; ULONG hash; if (!pRtlHashUnicodeString) { win_skip("RtlHashUnicodeString is not available\n"); return; } status = pRtlHashUnicodeString(NULL, FALSE, HASH_STRING_ALGORITHM_X65599, &hash); ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08x\n", status); RtlInitUnicodeString(&str, strW); status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_X65599, NULL); ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08x\n", status); status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_INVALID, &hash); ok(status == STATUS_INVALID_PARAMETER, "got status 0x%08x\n", status); /* embedded null */ str.Buffer = (PWSTR)strW; str.Length = sizeof(strW) - sizeof(WCHAR); str.MaximumLength = sizeof(strW); status = pRtlHashUnicodeString(&str, FALSE, HASH_STRING_ALGORITHM_X65599, &hash); ok(status == STATUS_SUCCESS, "got status 0x%08x\n", status); ok(hash == 0x32803083, "got 0x%08x\n", hash); ptr = hash_test; while (*ptr->str) { RtlInitUnicodeString(&str, ptr->str); hash = 0; status = pRtlHashUnicodeString(&str, ptr->case_insensitive, HASH_STRING_ALGORITHM_X65599, &hash); ok(status == STATUS_SUCCESS, "got status 0x%08x for %s\n", status, wine_dbgstr_w(ptr->str)); ok(hash == ptr->hash, "got wrong hash 0x%08x, expected 0x%08x, for %s, mode %d\n", hash, ptr->hash, wine_dbgstr_w(ptr->str), ptr->case_insensitive); ptr++; } } struct unicode_to_utf8_test { WCHAR unicode[128]; const char *expected; NTSTATUS status; }; static const struct unicode_to_utf8_test unicode_to_utf8[] = { { { 0 }, "", STATUS_SUCCESS }, { { '-',0 }, "-", STATUS_SUCCESS }, { { 'h','e','l','l','o',0 }, "hello", STATUS_SUCCESS }, { { '-',0x7f,'-',0x80,'-',0xff,'-',0x100,'-',0 }, "-\x7F-\xC2\x80-\xC3\xBF-\xC4\x80-", STATUS_SUCCESS }, { { '-',0x7ff,'-',0x800,'-',0 }, "-\xDF\xBF-\xE0\xA0\x80-", STATUS_SUCCESS }, { { '-',0xd7ff,'-',0xe000,'-',0 }, "-\xED\x9F\xBF-\xEE\x80\x80-", STATUS_SUCCESS }, /* 0x10000 */ { { '-',0xffff,'-',0xd800,0xdc00,'-',0 }, "-\xEF\xBF\xBF-\xF0\x90\x80\x80-", STATUS_SUCCESS }, /* 0x103ff */ /* 0x10400 */ { { '-',0xd800,0xdfff,'-',0xd801,0xdc00,'-',0 }, "-\xF0\x90\x8F\xBF-\xF0\x90\x90\x80-", STATUS_SUCCESS }, /* 0x10ffff */ { { '-',0xdbff,0xdfff,'-',0 }, "-\xF4\x8F\xBF\xBF-", STATUS_SUCCESS }, /* standalone lead surrogates become 0xFFFD */ { { '-',0xd800,'-',0xdbff,'-',0 }, "-\xEF\xBF\xBD-\xEF\xBF\xBD-", STATUS_SOME_NOT_MAPPED }, /* standalone trail surrogates become 0xFFFD */ { { '-',0xdc00,'-',0xdfff,'-',0 }, "-\xEF\xBF\xBD-\xEF\xBF\xBD-", STATUS_SOME_NOT_MAPPED }, /* reverse surrogate pair */ { { '-',0xdfff,0xdbff,'-',0 }, "-\xEF\xBF\xBD\xEF\xBF\xBD-", STATUS_SOME_NOT_MAPPED }, /* byte order marks */ { { '-',0xfeff,'-',0xfffe,'-',0 }, "-\xEF\xBB\xBF-\xEF\xBF\xBE-", STATUS_SUCCESS }, { { 0xfeff,'-',0 }, "\xEF\xBB\xBF-", STATUS_SUCCESS }, { { 0xfffe,'-',0 }, "\xEF\xBF\xBE-", STATUS_SUCCESS }, /* invalid code point */ { { 0xffff,'-',0 }, "\xEF\xBF\xBF-", STATUS_SUCCESS }, /* canonically equivalent representations -- no normalization should happen */ { { '-',0x1e09,'-',0 }, "-\xE1\xB8\x89-", STATUS_SUCCESS }, { { '-',0x0107,0x0327,'-',0 }, "-\xC4\x87\xCC\xA7-", STATUS_SUCCESS }, { { '-',0x00e7,0x0301,'-',0 }, "-\xC3\xA7\xCC\x81-", STATUS_SUCCESS }, { { '-',0x0063,0x0327,0x0301,'-',0 }, "-\x63\xCC\xA7\xCC\x81-", STATUS_SUCCESS }, { { '-',0x0063,0x0301,0x0327,'-',0 }, "-\x63\xCC\x81\xCC\xA7-", STATUS_SUCCESS }, }; static void utf8_expect_(const unsigned char *out_string, ULONG buflen, ULONG out_bytes, const WCHAR *in_string, ULONG in_bytes, NTSTATUS expect_status, int line) { NTSTATUS status; ULONG bytes_out; char buffer[128]; unsigned char *buf = (unsigned char *)buffer; unsigned int i; if (buflen == (ULONG)-1) buflen = sizeof(buffer); bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUnicodeToUTF8N( out_string ? buffer : NULL, buflen, &bytes_out, in_string, in_bytes); ok_(__FILE__, line)(status == expect_status, "status = 0x%x\n", status); ok_(__FILE__, line)(bytes_out == out_bytes, "bytes_out = %u\n", bytes_out); if (out_string) { for (i = 0; i < bytes_out; i++) ok_(__FILE__, line)(buf[i] == out_string[i], "buffer[%d] = 0x%x, expected 0x%x\n", i, buf[i], out_string[i]); for (; i < sizeof(buffer); i++) ok_(__FILE__, line)(buf[i] == 0x55, "buffer[%d] = 0x%x, expected 0x55\n", i, buf[i]); } } #define utf8_expect(out_string, buflen, out_bytes, in_string, in_bytes, expect_status) \ utf8_expect_(out_string, buflen, out_bytes, in_string, in_bytes, expect_status, __LINE__) static void test_RtlUnicodeToUTF8N(void) { NTSTATUS status; ULONG bytes_out; ULONG bytes_out_array[2]; void * const invalid_pointer = (void *)0x8; char buffer[128]; const WCHAR empty_string[] = { 0 }; const WCHAR test_string[] = { 'A',0,'a','b','c','d','e','f','g',0 }; const WCHAR special_string[] = { 'X',0x80,0xd800,0 }; const unsigned char special_expected[] = { 'X',0xc2,0x80,0xef,0xbf,0xbd,0 }; unsigned int input_len; const unsigned int test_count = ARRAY_SIZE(unicode_to_utf8); unsigned int i; if (!pRtlUnicodeToUTF8N) { skip("RtlUnicodeToUTF8N unavailable\n"); return; } /* show that bytes_out is really ULONG */ memset(bytes_out_array, 0x55, sizeof(bytes_out_array)); status = pRtlUnicodeToUTF8N(NULL, 0, bytes_out_array, empty_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out_array[0] == 0x00000000, "Got 0x%x\n", bytes_out_array[0]); ok(bytes_out_array[1] == 0x55555555, "Got 0x%x\n", bytes_out_array[1]); /* parameter checks */ status = pRtlUnicodeToUTF8N(NULL, 0, NULL, NULL, 0); ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%x\n", status); status = pRtlUnicodeToUTF8N(NULL, 0, NULL, empty_string, 0); ok(status == STATUS_INVALID_PARAMETER, "status = 0x%x\n", status); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, NULL, 0); ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%x\n", status); ok(bytes_out == 0x55555555, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, invalid_pointer, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, empty_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, test_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(NULL, 0, &bytes_out, empty_string, 1); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(invalid_pointer, 0, &bytes_out, empty_string, 1); ok(status == STATUS_INVALID_PARAMETER_5, "status = 0x%x\n", status); ok(bytes_out == 0x55555555, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUnicodeToUTF8N(invalid_pointer, 8, &bytes_out, empty_string, 1); ok(status == STATUS_INVALID_PARAMETER_5, "status = 0x%x\n", status); ok(bytes_out == 0x55555555, "bytes_out = 0x%x\n", bytes_out); /* length output with special chars */ #define length_expect(in_chars, out_bytes, expect_status) \ utf8_expect_(NULL, 0, out_bytes, \ special_string, in_chars * sizeof(WCHAR), \ expect_status, __LINE__) length_expect(0, 0, STATUS_SUCCESS); length_expect(1, 1, STATUS_SUCCESS); length_expect(2, 3, STATUS_SUCCESS); length_expect(3, 6, STATUS_SOME_NOT_MAPPED); length_expect(4, 7, STATUS_SOME_NOT_MAPPED); #undef length_expect /* output truncation */ #define truncate_expect(buflen, out_bytes, expect_status) \ utf8_expect_(special_expected, buflen, out_bytes, \ special_string, sizeof(special_string), \ expect_status, __LINE__) truncate_expect(0, 0, STATUS_BUFFER_TOO_SMALL); truncate_expect(1, 1, STATUS_BUFFER_TOO_SMALL); truncate_expect(2, 1, STATUS_BUFFER_TOO_SMALL); truncate_expect(3, 3, STATUS_BUFFER_TOO_SMALL); truncate_expect(4, 3, STATUS_BUFFER_TOO_SMALL); truncate_expect(5, 3, STATUS_BUFFER_TOO_SMALL); truncate_expect(6, 6, STATUS_BUFFER_TOO_SMALL); truncate_expect(7, 7, STATUS_SOME_NOT_MAPPED); #undef truncate_expect /* conversion behavior with varying input length */ for (input_len = 0; input_len <= sizeof(test_string); input_len++) { /* no output buffer, just length */ utf8_expect(NULL, 0, input_len / sizeof(WCHAR), test_string, input_len, STATUS_SUCCESS); /* write output */ bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUnicodeToUTF8N( buffer, sizeof(buffer), &bytes_out, test_string, input_len); if (input_len % sizeof(WCHAR) == 0) { ok(status == STATUS_SUCCESS, "(len %u): status = 0x%x\n", input_len, status); ok(bytes_out == input_len / sizeof(WCHAR), "(len %u): bytes_out = 0x%x\n", input_len, bytes_out); for (i = 0; i < bytes_out; i++) { ok(buffer[i] == test_string[i], "(len %u): buffer[%d] = 0x%x, expected 0x%x\n", input_len, i, buffer[i], test_string[i]); } for (; i < sizeof(buffer); i++) { ok(buffer[i] == 0x55, "(len %u): buffer[%d] = 0x%x\n", input_len, i, buffer[i]); } } else { ok(status == STATUS_INVALID_PARAMETER_5, "(len %u): status = 0x%x\n", input_len, status); ok(bytes_out == 0x55555555, "(len %u): bytes_out = 0x%x\n", input_len, bytes_out); for (i = 0; i < sizeof(buffer); i++) { ok(buffer[i] == 0x55, "(len %u): buffer[%d] = 0x%x\n", input_len, i, buffer[i]); } } } /* test cases for special characters */ for (i = 0; i < test_count; i++) { bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUnicodeToUTF8N( buffer, sizeof(buffer), &bytes_out, unicode_to_utf8[i].unicode, lstrlenW(unicode_to_utf8[i].unicode) * sizeof(WCHAR)); ok(status == unicode_to_utf8[i].status, "(test %d): status is 0x%x, expected 0x%x\n", i, status, unicode_to_utf8[i].status); ok(bytes_out == strlen(unicode_to_utf8[i].expected), "(test %d): bytes_out is %u, expected %u\n", i, bytes_out, lstrlenA(unicode_to_utf8[i].expected)); ok(!memcmp(buffer, unicode_to_utf8[i].expected, bytes_out), "(test %d): got \"%.*s\", expected \"%s\"\n", i, bytes_out, buffer, unicode_to_utf8[i].expected); ok(buffer[bytes_out] == 0x55, "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]); /* same test but include the null terminator */ bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUnicodeToUTF8N( buffer, sizeof(buffer), &bytes_out, unicode_to_utf8[i].unicode, (lstrlenW(unicode_to_utf8[i].unicode) + 1) * sizeof(WCHAR)); ok(status == unicode_to_utf8[i].status, "(test %d): status is 0x%x, expected 0x%x\n", i, status, unicode_to_utf8[i].status); ok(bytes_out == strlen(unicode_to_utf8[i].expected) + 1, "(test %d): bytes_out is %u, expected %u\n", i, bytes_out, lstrlenA(unicode_to_utf8[i].expected) + 1); ok(!memcmp(buffer, unicode_to_utf8[i].expected, bytes_out), "(test %d): got \"%.*s\", expected \"%s\"\n", i, bytes_out, buffer, unicode_to_utf8[i].expected); ok(buffer[bytes_out] == 0x55, "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]); } } struct utf8_to_unicode_test { const char *utf8; WCHAR expected[128]; NTSTATUS status; }; static const struct utf8_to_unicode_test utf8_to_unicode[] = { { "", { 0 }, STATUS_SUCCESS }, { "-", { '-',0 }, STATUS_SUCCESS }, { "hello", { 'h','e','l','l','o',0 }, STATUS_SUCCESS }, /* first and last of each range */ { "-\x7F-\xC2\x80-\xC3\xBF-\xC4\x80-", { '-',0x7f,'-',0x80,'-',0xff,'-',0x100,'-',0 }, STATUS_SUCCESS }, { "-\xDF\xBF-\xE0\xA0\x80-", { '-',0x7ff,'-',0x800,'-',0 }, STATUS_SUCCESS }, { "-\xED\x9F\xBF-\xEE\x80\x80-", { '-',0xd7ff,'-',0xe000,'-',0 }, STATUS_SUCCESS }, /* 0x10000 */ { "-\xEF\xBF\xBF-\xF0\x90\x80\x80-", { '-',0xffff,'-',0xd800,0xdc00,'-',0 }, STATUS_SUCCESS }, /* 0x103ff */ /* 0x10400 */ { "-\xF0\x90\x8F\xBF-\xF0\x90\x90\x80-", { '-',0xd800,0xdfff,'-',0xd801,0xdc00,'-',0 }, STATUS_SUCCESS }, /* 0x10ffff */ { "-\xF4\x8F\xBF\xBF-", { '-',0xdbff,0xdfff,'-',0 }, STATUS_SUCCESS }, /* standalone surrogate code points */ /* 0xd800 */ /* 0xdbff */ { "-\xED\xA0\x80-\xED\xAF\xBF-", { '-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0xdc00 */ /* 0xdfff */ { "-\xED\xB0\x80-\xED\xBF\xBF-", { '-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* UTF-8 encoded surrogate pair */ /* 0xdbff *//* 0xdfff */ { "-\xED\xAF\xBF\xED\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* reverse surrogate pair */ /* 0xdfff *//* 0xdbff */ { "-\xED\xBF\xBF\xED\xAF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* code points outside the UTF-16 range */ /* 0x110000 */ { "-\xF4\x90\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0x1fffff */ { "-\xF7\xBF\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0x200000 */ { "-\xFA\x80\x80\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0x3ffffff */ { "-\xFB\xBF\xBF\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0x4000000 */ { "-\xFC\x84\x80\x80\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* 0x7fffffff */ { "-\xFD\xBF\xBF\xBF\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* overlong encodings of each length for -, NUL, and the highest possible value */ { "-\xC0\xAD-\xC0\x80-\xC1\xBF-", { '-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xE0\x80\xAD-\xE0\x80\x80-\xE0\x9F\xBF-", { '-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF0\x80\x80\xAD-", { '-',0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF0\x80\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF0\x8F\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF8\x80\x80\x80\xAD-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF8\x80\x80\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xF8\x87\xBF\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xFC\x80\x80\x80\x80\xAD-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xFC\x80\x80\x80\x80\x80-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "-\xFC\x83\xBF\xBF\xBF\xBF-", { '-',0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* invalid bytes */ { "\xFE", { 0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xFF", { 0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xFE\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF", { 0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xFF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF", { 0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xFF\x80\x80\x80\x80\x80\x80\x80\x80", { 0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xFF\x40\x80\x80\x80\x80\x80\x80\x80", { 0xfffd,0x40,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, /* lone continuation bytes */ { "\x80", { 0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\x80\x80", { 0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xBF", { 0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, { "\xBF\xBF", { 0xfffd,0xfffd,0 }, STATUS_SOME_NOT_MAPPED }, /* incomplete sequences */ { "\xC2-", { 0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "\xE0\xA0-", { 0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "\xF0\x90\x80-", { 0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "\xF4\x8F\xBF-", { 0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "\xFA\x80\x80\x80-", { 0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, { "\xFC\x84\x80\x80\x80-", { 0xfffd,0xfffd,0xfffd,0xfffd,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* multibyte sequence followed by lone continuation byte */ { "\xE0\xA0\x80\x80-", { 0x800,0xfffd,'-',0 }, STATUS_SOME_NOT_MAPPED }, /* byte order marks */ { "-\xEF\xBB\xBF-\xEF\xBF\xBE-", { '-',0xfeff,'-',0xfffe,'-',0 }, STATUS_SUCCESS }, { "\xEF\xBB\xBF-", { 0xfeff,'-',0 }, STATUS_SUCCESS }, { "\xEF\xBF\xBE-", { 0xfffe,'-',0 }, STATUS_SUCCESS }, /* invalid code point */ /* 0xffff */ { "\xEF\xBF\xBF-", { 0xffff,'-',0 }, STATUS_SUCCESS }, /* canonically equivalent representations -- no normalization should happen */ { "-\xE1\xB8\x89-", { '-',0x1e09,'-',0 }, STATUS_SUCCESS }, { "-\xC4\x87\xCC\xA7-", { '-',0x0107,0x0327,'-',0 }, STATUS_SUCCESS }, { "-\xC3\xA7\xCC\x81-", { '-',0x00e7,0x0301,'-',0 }, STATUS_SUCCESS }, { "-\x63\xCC\xA7\xCC\x81-", { '-',0x0063,0x0327,0x0301,'-',0 }, STATUS_SUCCESS }, { "-\x63\xCC\x81\xCC\xA7-", { '-',0x0063,0x0301,0x0327,'-',0 }, STATUS_SUCCESS }, }; static void unicode_expect_(const WCHAR *out_string, ULONG buflen, ULONG out_chars, const char *in_string, ULONG in_chars, NTSTATUS expect_status, int line) { NTSTATUS status; ULONG bytes_out; WCHAR buffer[128]; unsigned int i; if (buflen == (ULONG)-1) buflen = sizeof(buffer); bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUTF8ToUnicodeN( out_string ? buffer : NULL, buflen, &bytes_out, in_string, in_chars); ok_(__FILE__, line)(status == expect_status, "status = 0x%x\n", status); ok_(__FILE__, line)(bytes_out == out_chars * sizeof(WCHAR), "bytes_out = %u, expected %u\n", bytes_out, out_chars * (ULONG)sizeof(WCHAR)); if (out_string) { for (i = 0; i < bytes_out / sizeof(WCHAR); i++) ok_(__FILE__, line)(buffer[i] == out_string[i], "buffer[%d] = 0x%x, expected 0x%x\n", i, buffer[i], out_string[i]); for (; i < ARRAY_SIZE(buffer); i++) ok_(__FILE__, line)(buffer[i] == 0x5555, "buffer[%d] = 0x%x, expected 0x5555\n", i, buffer[i]); } } #define unicode_expect(out_string, buflen, out_chars, in_string, in_chars, expect_status) \ unicode_expect_(out_string, buflen, out_chars, in_string, in_chars, expect_status, __LINE__) static void test_RtlUTF8ToUnicodeN(void) { NTSTATUS status; ULONG bytes_out; ULONG bytes_out_array[2]; void * const invalid_pointer = (void *)0x8; WCHAR buffer[128]; const char empty_string[] = ""; const char test_string[] = "A\0abcdefg"; const WCHAR test_stringW[] = {'A',0,'a','b','c','d','e','f','g',0 }; const char special_string[] = { 'X',0xc2,0x80,0xF0,0x90,0x80,0x80,0 }; const WCHAR special_expected[] = { 'X',0x80,0xd800,0xdc00,0 }; unsigned int input_len; const unsigned int test_count = ARRAY_SIZE(utf8_to_unicode); unsigned int i; if (!pRtlUTF8ToUnicodeN) { skip("RtlUTF8ToUnicodeN unavailable\n"); return; } /* show that bytes_out is really ULONG */ memset(bytes_out_array, 0x55, sizeof(bytes_out_array)); status = pRtlUTF8ToUnicodeN(NULL, 0, bytes_out_array, empty_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out_array[0] == 0x00000000, "Got 0x%x\n", bytes_out_array[0]); ok(bytes_out_array[1] == 0x55555555, "Got 0x%x\n", bytes_out_array[1]); /* parameter checks */ status = pRtlUTF8ToUnicodeN(NULL, 0, NULL, NULL, 0); ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%x\n", status); status = pRtlUTF8ToUnicodeN(NULL, 0, NULL, empty_string, 0); ok(status == STATUS_INVALID_PARAMETER, "status = 0x%x\n", status); bytes_out = 0x55555555; status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, NULL, 0); ok(status == STATUS_INVALID_PARAMETER_4, "status = 0x%x\n", status); ok(bytes_out == 0x55555555, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, invalid_pointer, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, empty_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, test_string, 0); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == 0, "bytes_out = 0x%x\n", bytes_out); bytes_out = 0x55555555; status = pRtlUTF8ToUnicodeN(NULL, 0, &bytes_out, empty_string, 1); ok(status == STATUS_SUCCESS, "status = 0x%x\n", status); ok(bytes_out == sizeof(WCHAR), "bytes_out = 0x%x\n", bytes_out); /* length output with special chars */ #define length_expect(in_chars, out_chars, expect_status) \ unicode_expect_(NULL, 0, out_chars, special_string, in_chars, \ expect_status, __LINE__) length_expect(0, 0, STATUS_SUCCESS); length_expect(1, 1, STATUS_SUCCESS); length_expect(2, 2, STATUS_SOME_NOT_MAPPED); length_expect(3, 2, STATUS_SUCCESS); length_expect(4, 3, STATUS_SOME_NOT_MAPPED); length_expect(5, 3, STATUS_SOME_NOT_MAPPED); length_expect(6, 3, STATUS_SOME_NOT_MAPPED); length_expect(7, 4, STATUS_SUCCESS); length_expect(8, 5, STATUS_SUCCESS); #undef length_expect /* output truncation */ #define truncate_expect(buflen, out_chars, expect_status) \ unicode_expect_(special_expected, buflen, out_chars, \ special_string, sizeof(special_string), \ expect_status, __LINE__) truncate_expect( 0, 0, STATUS_BUFFER_TOO_SMALL); truncate_expect( 1, 0, STATUS_BUFFER_TOO_SMALL); truncate_expect( 2, 1, STATUS_BUFFER_TOO_SMALL); truncate_expect( 3, 1, STATUS_BUFFER_TOO_SMALL); truncate_expect( 4, 2, STATUS_BUFFER_TOO_SMALL); truncate_expect( 5, 2, STATUS_BUFFER_TOO_SMALL); truncate_expect( 6, 3, STATUS_BUFFER_TOO_SMALL); truncate_expect( 7, 3, STATUS_BUFFER_TOO_SMALL); truncate_expect( 8, 4, STATUS_BUFFER_TOO_SMALL); truncate_expect( 9, 4, STATUS_BUFFER_TOO_SMALL); truncate_expect(10, 5, STATUS_SUCCESS); #undef truncate_expect /* conversion behavior with varying input length */ for (input_len = 0; input_len <= sizeof(test_string); input_len++) { /* no output buffer, just length */ unicode_expect(NULL, 0, input_len, test_string, input_len, STATUS_SUCCESS); /* write output */ unicode_expect(test_stringW, -1, input_len, test_string, input_len, STATUS_SUCCESS); } /* test cases for special characters */ for (i = 0; i < test_count; i++) { bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUTF8ToUnicodeN( buffer, sizeof(buffer), &bytes_out, utf8_to_unicode[i].utf8, strlen(utf8_to_unicode[i].utf8)); ok(status == utf8_to_unicode[i].status, "(test %d): status is 0x%x, expected 0x%x\n", i, status, utf8_to_unicode[i].status); ok(bytes_out == lstrlenW(utf8_to_unicode[i].expected) * sizeof(WCHAR), "(test %d): bytes_out is %u, expected %u\n", i, bytes_out, lstrlenW(utf8_to_unicode[i].expected) * (ULONG)sizeof(WCHAR)); ok(!memcmp(buffer, utf8_to_unicode[i].expected, bytes_out), "(test %d): got %s, expected %s\n", i, wine_dbgstr_wn(buffer, bytes_out / sizeof(WCHAR)), wine_dbgstr_w(utf8_to_unicode[i].expected)); ok(buffer[bytes_out] == 0x5555, "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]); /* same test but include the null terminator */ bytes_out = 0x55555555; memset(buffer, 0x55, sizeof(buffer)); status = pRtlUTF8ToUnicodeN( buffer, sizeof(buffer), &bytes_out, utf8_to_unicode[i].utf8, strlen(utf8_to_unicode[i].utf8) + 1); ok(status == utf8_to_unicode[i].status, "(test %d): status is 0x%x, expected 0x%x\n", i, status, utf8_to_unicode[i].status); ok(bytes_out == (lstrlenW(utf8_to_unicode[i].expected) + 1) * sizeof(WCHAR), "(test %d): bytes_out is %u, expected %u\n", i, bytes_out, (lstrlenW(utf8_to_unicode[i].expected) + 1) * (ULONG)sizeof(WCHAR)); ok(!memcmp(buffer, utf8_to_unicode[i].expected, bytes_out), "(test %d): got %s, expected %s\n", i, wine_dbgstr_wn(buffer, bytes_out / sizeof(WCHAR)), wine_dbgstr_w(utf8_to_unicode[i].expected)); ok(buffer[bytes_out] == 0x5555, "(test %d): behind string: 0x%x\n", i, buffer[bytes_out]); } } START_TEST(rtlstr) { InitFunctionPtrs(); if (pRtlInitAnsiString) { test_RtlInitString(); test_RtlInitUnicodeString(); test_RtlCopyString(); test_RtlUnicodeStringToInteger(); test_RtlCharToInteger(); test_RtlIntegerToUnicodeString(); test_RtlIntegerToChar(); test_RtlUpperChar(); test_RtlUpperString(); test_RtlUnicodeStringToAnsiString(); test_RtlAppendAsciizToString(); test_RtlAppendStringToString(); test_RtlAppendUnicodeToString(); test_RtlAppendUnicodeStringToString(); } test_RtlInitUnicodeStringEx(); test_RtlDuplicateUnicodeString(); test_RtlFindCharInUnicodeString(); test_RtlGUIDFromString(); test_RtlStringFromGUID(); test_RtlIsTextUnicode(); test_RtlCompareUnicodeString(); if(0) { test_RtlUpcaseUnicodeChar(); test_RtlUpcaseUnicodeString(); test_RtlDowncaseUnicodeString(); } test_RtlHashUnicodeString(); test_RtlUnicodeToUTF8N(); test_RtlUTF8ToUnicodeN(); }