git.oblomov.eu Git - wine/blob - dlls/ntdll/tests/rtlstr.c

   1 /* Unit test suite for Rtl string functions
   2  *
   3  * Copyright 2002 Robert Shearman
   4  * Copyright 2003 Thomas Mertes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTES
  21  * We use function pointers here as there is no import library for NTDLL on
  22  * windows.
  23  */
  24
  25 #include <stdlib.h>
  26
  27 #define INITGUID
  28
  29 #include "ntdll_test.h"
  30 #include "winnls.h"
  31 #include "guiddef.h"
  32
  33 /* Function ptrs for ntdll calls */
  34 static HMODULE hntdll = 0;
  35 static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN);
  36 static NTSTATUS (WINAPI *pRtlAppendAsciizToString)(STRING *, LPCSTR);
  37 static NTSTATUS (WINAPI *pRtlAppendStringToString)(STRING *, const STRING *);
  38 static NTSTATUS (WINAPI *pRtlAppendUnicodeStringToString)(UNICODE_STRING *, const UNICODE_STRING *);
  39 static NTSTATUS (WINAPI *pRtlAppendUnicodeToString)(UNICODE_STRING *, LPCWSTR);
  40 static NTSTATUS (WINAPI *pRtlCharToInteger)(PCSZ, ULONG, int *);
  41 static VOID     (WINAPI *pRtlCopyString)(STRING *, const STRING *);
  42 static BOOLEAN  (WINAPI *pRtlCreateUnicodeString)(PUNICODE_STRING, LPCWSTR);
  43 static BOOLEAN  (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
  44 static NTSTATUS (WINAPI *pRtlDowncaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
  45 static NTSTATUS (WINAPI *pRtlDuplicateUnicodeString)(int, UNICODE_STRING *, UNICODE_STRING *);
  46 static BOOLEAN  (WINAPI *pRtlEqualUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
  47 static NTSTATUS (WINAPI *pRtlFindCharInUnicodeString)(int, const UNICODE_STRING *, const UNICODE_STRING *, USHORT *);
  48 static VOID     (WINAPI *pRtlFreeAnsiString)(PSTRING);
  49 static VOID     (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
  50 static VOID     (WINAPI *pRtlInitAnsiString)(PSTRING, LPCSTR);
  51 static VOID     (WINAPI *pRtlInitString)(PSTRING, LPCSTR);
  52 static VOID     (WINAPI *pRtlInitUnicodeString)(PUNICODE_STRING, LPCWSTR);
  53 static NTSTATUS (WINAPI *pRtlInitUnicodeStringEx)(PUNICODE_STRING, LPCWSTR);
  54 static NTSTATUS (WINAPI *pRtlIntegerToChar)(ULONG, ULONG, ULONG, PCHAR);
  55 static NTSTATUS (WINAPI *pRtlIntegerToUnicodeString)(ULONG, ULONG, UNICODE_STRING *);
  56 static NTSTATUS (WINAPI *pRtlMultiAppendUnicodeStringBuffer)(UNICODE_STRING *, LONG, UNICODE_STRING *);
  57 static NTSTATUS (WINAPI *pRtlUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);
  58 static NTSTATUS (WINAPI *pRtlUnicodeStringToInteger)(const UNICODE_STRING *, int, int *);
  59 static WCHAR    (WINAPI *pRtlUpcaseUnicodeChar)(WCHAR);
  60 static NTSTATUS (WINAPI *pRtlUpcaseUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);
  61 static CHAR     (WINAPI *pRtlUpperChar)(CHAR);
  62 static NTSTATUS (WINAPI *pRtlUpperString)(STRING *, const STRING *);
  63 static NTSTATUS (WINAPI *pRtlValidateUnicodeString)(LONG, UNICODE_STRING *);
  64 static NTSTATUS (WINAPI *pRtlGUIDFromString)(const UNICODE_STRING*,GUID*);
  65 static NTSTATUS (WINAPI *pRtlStringFromGUID)(const GUID*, UNICODE_STRING*);
  66 static BOOLEAN (WINAPI *pRtlIsTextUnicode)(LPVOID, INT, INT *);
  67
  68 /*static VOID (WINAPI *pRtlFreeOemString)(PSTRING);*/
  69 /*static VOID (WINAPI *pRtlCopyUnicodeString)(UNICODE_STRING *, const UNICODE_STRING *);*/
  70 /*static VOID (WINAPI *pRtlEraseUnicodeString)(UNICODE_STRING *);*/
  71 /*static LONG (WINAPI *pRtlCompareString)(const STRING *,const STRING *,BOOLEAN);*/
  72 /*static LONG (WINAPI *pRtlCompareUnicodeString)(const UNICODE_STRING *,const UNICODE_STRING *,BOOLEAN);*/
  73 /*static BOOLEAN (WINAPI *pRtlEqualString)(const STRING *,const STRING *,BOOLEAN);*/
  74 /*static BOOLEAN (WINAPI *pRtlPrefixString)(const STRING *, const STRING *, BOOLEAN);*/
  75 /*static BOOLEAN (WINAPI *pRtlPrefixUnicodeString)(const UNICODE_STRING *, const UNICODE_STRING *, BOOLEAN);*/
  76 /*static NTSTATUS (WINAPI *pRtlOemStringToUnicodeString)(PUNICODE_STRING, const STRING *, BOOLEAN);*/
  77 /*static NTSTATUS (WINAPI *pRtlUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
  78 /*static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/
  79 /*static NTSTATUS (WINAPI *pRtlOemToUnicodeN)(LPWSTR, DWORD, LPDWORD, LPCSTR, DWORD);*/
  80 /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToAnsiString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
  81 /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeStringToOemString)(STRING *, const UNICODE_STRING *, BOOLEAN);*/
  82 /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToMultiByteN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/
  83 /*static NTSTATUS (WINAPI *pRtlUpcaseUnicodeToOemN)(LPSTR, DWORD, LPDWORD, LPCWSTR, DWORD);*/
  84 /*static UINT (WINAPI *pRtlOemToUnicodeSize)(const STRING *);*/
  85 /*static DWORD (WINAPI *pRtlAnsiStringToUnicodeSize)(const STRING *);*/
  86
  87
  88 static WCHAR* AtoW( const char* p )
  89 {
  90     WCHAR* buffer;
  91     DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
  92     buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR) );
  93     MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len );
  94     return buffer;
  95 }
  96
  97
  98 static void InitFunctionPtrs(void)
  99 {
 100     hntdll = LoadLibraryA("ntdll.dll");
 101     ok(hntdll != 0, "LoadLibrary failed\n");
 102     if (hntdll) {
 103         pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
 104         pRtlAppendAsciizToString = (void *)GetProcAddress(hntdll, "RtlAppendAsciizToString");
 105         pRtlAppendStringToString = (void *)GetProcAddress(hntdll, "RtlAppendStringToString");
 106         pRtlAppendUnicodeStringToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeStringToString");
 107         pRtlAppendUnicodeToString = (void *)GetProcAddress(hntdll, "RtlAppendUnicodeToString");
 108         pRtlCharToInteger = (void *)GetProcAddress(hntdll, "RtlCharToInteger");
 109         pRtlCopyString = (void *)GetProcAddress(hntdll, "RtlCopyString");
 110         pRtlCreateUnicodeString = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeString");
 111         pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
 112         pRtlDowncaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlDowncaseUnicodeString");
 113         pRtlDuplicateUnicodeString = (void *)GetProcAddress(hntdll, "RtlDuplicateUnicodeString");
 114         pRtlEqualUnicodeString = (void *)GetProcAddress(hntdll, "RtlEqualUnicodeString");
 115         pRtlFindCharInUnicodeString = (void *)GetProcAddress(hntdll, "RtlFindCharInUnicodeString");
 116         pRtlFreeAnsiString = (void *)GetProcAddress(hntdll, "RtlFreeAnsiString");
 117         pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
 118         pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
 119         pRtlInitString = (void *)GetProcAddress(hntdll, "RtlInitString");
 120         pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
 121         pRtlInitUnicodeStringEx = (void *)GetProcAddress(hntdll, "RtlInitUnicodeStringEx");
 122         pRtlIntegerToChar = (void *)GetProcAddress(hntdll, "RtlIntegerToChar");
 123         pRtlIntegerToUnicodeString = (void *)GetProcAddress(hntdll, "RtlIntegerToUnicodeString");
 124         pRtlMultiAppendUnicodeStringBuffer = (void *)GetProcAddress(hntdll, "RtlMultiAppendUnicodeStringBuffer");
 125         pRtlUnicodeStringToAnsiString = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToAnsiString");
 126         pRtlUnicodeStringToInteger = (void *)GetProcAddress(hntdll, "RtlUnicodeStringToInteger");
 127         pRtlUpcaseUnicodeChar = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeChar");
 128         pRtlUpcaseUnicodeString = (void *)GetProcAddress(hntdll, "RtlUpcaseUnicodeString");
 129         pRtlUpperChar = (void *)GetProcAddress(hntdll, "RtlUpperChar");
 130         pRtlUpperString = (void *)GetProcAddress(hntdll, "RtlUpperString");
 131         pRtlValidateUnicodeString = (void *)GetProcAddress(hntdll, "RtlValidateUnicodeString");
 132         pRtlGUIDFromString = (void *)GetProcAddress(hntdll, "RtlGUIDFromString");
 133         pRtlStringFromGUID = (void *)GetProcAddress(hntdll, "RtlStringFromGUID");
 134         pRtlIsTextUnicode = (void *)GetProcAddress(hntdll, "RtlIsTextUnicode");
 135     }
 136 }
 137
 138
 139 static void test_RtlInitString(void)
 140 {
 141     static const char teststring[] = "Some Wild String";
 142     STRING str;
 143
 144     str.Length = 0;
 145     str.MaximumLength = 0;
 146     str.Buffer = (void *)0xdeadbeef;
 147     pRtlInitString(&str, teststring);
 148     ok(str.Length == sizeof(teststring) - sizeof(char), "Length uninitialized\n");
 149     ok(str.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
 150     ok(str.Buffer == teststring, "Buffer not equal to teststring\n");
 151     ok(strcmp(str.Buffer, "Some Wild String") == 0, "Buffer written to\n");
 152     pRtlInitString(&str, NULL);
 153     ok(str.Length == 0, "Length uninitialized\n");
 154     ok(str.MaximumLength == 0, "MaximumLength uninitialized\n");
 155     ok(str.Buffer == NULL, "Buffer not equal to NULL\n");
 156 /*  pRtlInitString(NULL, teststring); */
 157 }
 158
 159
 160 static void test_RtlInitUnicodeString(void)
 161 {
 162 #define STRINGW {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0}
 163     static const WCHAR teststring[] = STRINGW;
 164     static const WCHAR originalstring[] = STRINGW;
 165 #undef STRINGW
 166     UNICODE_STRING uni;
 167
 168     uni.Length = 0;
 169     uni.MaximumLength = 0;
 170     uni.Buffer = (void *)0xdeadbeef;
 171     pRtlInitUnicodeString(&uni, teststring);
 172     ok(uni.Length == sizeof(teststring) - sizeof(WCHAR), "Length uninitialized\n");
 173     ok(uni.MaximumLength == sizeof(teststring), "MaximumLength uninitialized\n");
 174     ok(uni.Buffer == teststring, "Buffer not equal to teststring\n");
 175     ok(lstrcmpW(uni.Buffer, originalstring) == 0, "Buffer written to\n");
 176     pRtlInitUnicodeString(&uni, NULL);
 177     ok(uni.Length == 0, "Length uninitialized\n");
 178     ok(uni.MaximumLength == 0, "MaximumLength uninitialized\n");
 179     ok(uni.Buffer == NULL, "Buffer not equal to NULL\n");
 180 /*  pRtlInitUnicodeString(NULL, teststring); */
 181 }
 182
 183
 184 #define TESTSTRING2_LEN 1000000
 185 /* #define TESTSTRING2_LEN 32766 */
 186
 187
 188 static void test_RtlInitUnicodeStringEx(void)
 189 {
 190     static const WCHAR teststring[] = {'S','o','m','e',' ','W','i','l','d',' ','S','t','r','i','n','g',0};
 191     WCHAR *teststring2;
 192     UNICODE_STRING uni;
 193     NTSTATUS result;
 194
 195     teststring2 = HeapAlloc(GetProcessHeap(), 0, (TESTSTRING2_LEN + 1) * sizeof(WCHAR));
 196     memset(teststring2, 'X', TESTSTRING2_LEN * sizeof(WCHAR));
 197     teststring2[TESTSTRING2_LEN] = '\0';
 198
 199     uni.Length = 12345;
 200     uni.MaximumLength = 12345;
 201     uni.Buffer = (void *) 0xdeadbeef;
 202     result = pRtlInitUnicodeStringEx(&uni, teststring);
 203     ok(result == STATUS_SUCCESS,
 204        "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected 0\n",
 205        result);
 206     ok(uni.Length == 32,
 207        "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
 208        uni.Length, 32);
 209     ok(uni.MaximumLength == 34,
 210        "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
 211        uni.MaximumLength, 34);
 212     ok(uni.Buffer == teststring,
 213        "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
 214        uni.Buffer, teststring);
 215
 216     uni.Length = 12345;
 217     uni.MaximumLength = 12345;
 218     uni.Buffer = (void *) 0xdeadbeef;
 219     pRtlInitUnicodeString(&uni, teststring);
 220     ok(uni.Length == 32,
 221        "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
 222        uni.Length, 32);
 223     ok(uni.MaximumLength == 34,
 224        "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
 225        uni.MaximumLength, 34);
 226     ok(uni.Buffer == teststring,
 227        "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
 228        uni.Buffer, teststring);
 229
 230     uni.Length = 12345;
 231     uni.MaximumLength = 12345;
 232     uni.Buffer = (void *) 0xdeadbeef;
 233     result = pRtlInitUnicodeStringEx(&uni, teststring2);
 234     ok(result == STATUS_NAME_TOO_LONG,
 235        "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected %x\n",
 236        result, STATUS_NAME_TOO_LONG);
 237     ok(uni.Length == 12345 ||
 238        uni.Length == 0, /* win2k3 */
 239        "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected 12345 or 0\n",
 240        uni.Length);
 241     ok(uni.MaximumLength == 12345 ||
 242        uni.MaximumLength == 0, /* win2k3 */
 243        "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected 12345 or 0\n",
 244        uni.MaximumLength);
 245     ok(uni.Buffer == (void *) 0xdeadbeef ||
 246        uni.Buffer == teststring2, /* win2k3 */
 247        "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %x or %p\n",
 248        uni.Buffer, 0xdeadbeef, teststring2);
 249
 250     uni.Length = 12345;
 251     uni.MaximumLength = 12345;
 252     uni.Buffer = (void *) 0xdeadbeef;
 253     pRtlInitUnicodeString(&uni, teststring2);
 254     ok(uni.Length == 33920 /* <= Win2000 */ || uni.Length == 65532 /* >= Win XP */,
 255        "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
 256        uni.Length, 65532);
 257     ok(uni.MaximumLength == 33922 /* <= Win2000 */ || uni.MaximumLength == 65534 /* >= Win XP */,
 258        "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
 259        uni.MaximumLength, 65534);
 260     ok(uni.Buffer == teststring2,
 261        "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
 262        uni.Buffer, teststring2);
 263     ok(memcmp(uni.Buffer, teststring2, (TESTSTRING2_LEN + 1) * sizeof(WCHAR)) == 0,
 264        "pRtlInitUnicodeString(&uni, 0) changes Buffer\n");
 265
 266     uni.Length = 12345;
 267     uni.MaximumLength = 12345;
 268     uni.Buffer = (void *) 0xdeadbeef;
 269     result = pRtlInitUnicodeStringEx(&uni, 0);
 270     ok(result == STATUS_SUCCESS,
 271        "pRtlInitUnicodeStringEx(&uni, 0) returns %x, expected 0\n",
 272        result);
 273     ok(uni.Length == 0,
 274        "pRtlInitUnicodeStringEx(&uni, 0) sets Length to %u, expected %u\n",
 275        uni.Length, 0);
 276     ok(uni.MaximumLength == 0,
 277        "pRtlInitUnicodeStringEx(&uni, 0) sets MaximumLength to %u, expected %u\n",
 278        uni.MaximumLength, 0);
 279     ok(uni.Buffer == NULL,
 280        "pRtlInitUnicodeStringEx(&uni, 0) sets Buffer to %p, expected %p\n",
 281        uni.Buffer, NULL);
 282
 283     uni.Length = 12345;
 284     uni.MaximumLength = 12345;
 285     uni.Buffer = (void *) 0xdeadbeef;
 286     pRtlInitUnicodeString(&uni, 0);
 287     ok(uni.Length == 0,
 288        "pRtlInitUnicodeString(&uni, 0) sets Length to %u, expected %u\n",
 289        uni.Length, 0);
 290     ok(uni.MaximumLength == 0,
 291        "pRtlInitUnicodeString(&uni, 0) sets MaximumLength to %u, expected %u\n",
 292        uni.MaximumLength, 0);
 293     ok(uni.Buffer == NULL,
 294        "pRtlInitUnicodeString(&uni, 0) sets Buffer to %p, expected %p\n",
 295        uni.Buffer, NULL);
 296
 297     HeapFree(GetProcessHeap(), 0, teststring2);
 298 }
 299
 300
 301 typedef struct {
 302     int add_nul;
 303     int source_Length;
 304     int source_MaximumLength;
 305     int source_buf_size;
 306     const char *source_buf;
 307     int dest_Length;
 308     int dest_MaximumLength;
 309     int dest_buf_size;
 310     const char *dest_buf;
 311     int res_Length;
 312     int res_MaximumLength;
 313     int res_buf_size;
 314     const char *res_buf;
 315     NTSTATUS result;
 316 } dupl_ustr_t;
 317
 318 static const dupl_ustr_t dupl_ustr[] = {
 319     { 0, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string",     STATUS_SUCCESS},
 320     { 0, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 32, 32, "This is a string",     STATUS_SUCCESS},
 321     { 0, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 322     { 0, 32, 34, 34, "This is a string", 40, 42, 42, NULL,                   32, 32, 32, "This is a string",     STATUS_SUCCESS},
 323     { 0, 32, 32, 32, "This is a string", 40, 42, 42, NULL,                   32, 32, 32, "This is a string",     STATUS_SUCCESS},
 324     { 0, 32, 30, 34, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 325     { 1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string",     STATUS_SUCCESS},
 326     { 1, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string",     STATUS_SUCCESS},
 327     { 1, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 328     { 1, 32, 34, 34, "This is a string", 40, 42, 42, NULL,                   32, 34, 34, "This is a string",     STATUS_SUCCESS},
 329     { 1, 32, 32, 32, "This is a string", 40, 42, 42, NULL,                   32, 34, 34, "This is a string",     STATUS_SUCCESS},
 330     { 1, 32, 30, 34, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 331     { 2, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 332     { 2, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 333     { 2, 32, 30, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 334     { 2, 32, 34, 34, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 335     { 2, 32, 32, 32, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 336     { 2, 32, 30, 34, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 337     { 3, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string",     STATUS_SUCCESS},
 338     { 3, 32, 32, 32, "This is a string", 40, 42, 42, "--------------------", 32, 34, 34, "This is a string",     STATUS_SUCCESS},
 339     { 3, 32, 30, 32, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 340     { 3, 32, 34, 34, "This is a string", 40, 42, 42, NULL,                   32, 34, 34, "This is a string",     STATUS_SUCCESS},
 341     { 3, 32, 32, 32, "This is a string", 40, 42, 42, NULL,                   32, 34, 34, "This is a string",     STATUS_SUCCESS},
 342     { 3, 32, 30, 32, "This is a string", 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 343     { 4, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 344     { 5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 345     { 6, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 346     { 7, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 347     { 8, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 348     { 9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 349     {10, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 350     {11, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 351     {12, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 352     {13, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 353     {14, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 354     {15, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 355     {16, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 356     {-1, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 357     {-5, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 358     {-9, 32, 34, 34, "This is a string", 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 359     { 0,  0,  2,  2, "",                 40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 360     { 0,  0,  0,  0, "",                 40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 361     { 0,  0,  2,  2, "",                 40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 362     { 0,  0,  0,  0, "",                 40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 363     { 0,  0,  2,  2, NULL,               40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 364     { 0,  0,  0,  0, NULL,               40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 365     { 0,  0,  2,  2, NULL,               40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 366     { 0,  0,  0,  0, NULL,               40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 367     { 1,  0,  2,  2, "",                 40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 368     { 1,  0,  0,  0, "",                 40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 369     { 1,  0,  2,  2, "",                 40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 370     { 1,  0,  0,  0, "",                 40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 371     { 1,  0,  2,  2, NULL,               40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 372     { 1,  0,  0,  0, NULL,               40, 42, 42, "--------------------",  0,  0,  0, NULL,                   STATUS_SUCCESS},
 373     { 1,  0,  2,  2, NULL,               40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 374     { 1,  0,  0,  0, NULL,               40, 42, 42, NULL,                    0,  0,  0, NULL,                   STATUS_SUCCESS},
 375     { 2,  0,  2,  2, "",                 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 376     { 2,  0,  0,  0, "",                 40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 377     { 2,  0,  2,  2, "",                 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 378     { 2,  0,  0,  0, "",                 40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 379     { 2,  0,  2,  2, NULL,               40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 380     { 2,  0,  0,  0, NULL,               40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 381     { 2,  0,  2,  2, NULL,               40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 382     { 2,  0,  0,  0, NULL,               40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 383     { 3,  0,  2,  2, "",                 40, 42, 42, "--------------------",  0,  2,  2, "",                     STATUS_SUCCESS},
 384     { 3,  0,  0,  0, "",                 40, 42, 42, "--------------------",  0,  2,  2, "",                     STATUS_SUCCESS},
 385     { 3,  0,  2,  2, "",                 40, 42, 42, NULL,                    0,  2,  2, "",                     STATUS_SUCCESS},
 386     { 3,  0,  0,  0, "",                 40, 42, 42, NULL,                    0,  2,  2, "",                     STATUS_SUCCESS},
 387     { 3,  0,  2,  2, NULL,               40, 42, 42, "--------------------", 40, 42, 42, "--------------------", STATUS_INVALID_PARAMETER},
 388     { 3,  0,  0,  0, NULL,               40, 42, 42, "--------------------",  0,  2,  2, "",                     STATUS_SUCCESS},
 389     { 3,  0,  2,  2, NULL,               40, 42, 42, NULL,                   40, 42,  0, NULL,                   STATUS_INVALID_PARAMETER},
 390     { 3,  0,  0,  0, NULL,               40, 42, 42, NULL,                    0,  2,  2, "",                     STATUS_SUCCESS},
 391 };
 392 #define NB_DUPL_USTR (sizeof(dupl_ustr)/sizeof(*dupl_ustr))
 393
 394
 395 static void test_RtlDuplicateUnicodeString(void)
 396 {
 397     size_t pos;
 398     WCHAR source_buf[257];
 399     WCHAR dest_buf[257];
 400     WCHAR res_buf[257];
 401     UNICODE_STRING source_str;
 402     UNICODE_STRING dest_str;
 403     UNICODE_STRING res_str;
 404     CHAR dest_ansi_buf[257];
 405     STRING dest_ansi_str;
 406     NTSTATUS result;
 407     unsigned int test_num;
 408
 409     for (test_num = 0; test_num < NB_DUPL_USTR; test_num++) {
 410         source_str.Length        = dupl_ustr[test_num].source_Length;
 411         source_str.MaximumLength = dupl_ustr[test_num].source_MaximumLength;
 412         if (dupl_ustr[test_num].source_buf != NULL) {
 413             for (pos = 0; pos < dupl_ustr[test_num].source_buf_size/sizeof(WCHAR); pos++) {
 414                 source_buf[pos] = dupl_ustr[test_num].source_buf[pos];
 415             }
 416             source_str.Buffer = source_buf;
 417         } else {
 418             source_str.Buffer = NULL;
 419         }
 420         dest_str.Length        = dupl_ustr[test_num].dest_Length;
 421         dest_str.MaximumLength = dupl_ustr[test_num].dest_MaximumLength;
 422         if (dupl_ustr[test_num].dest_buf != NULL) {
 423             for (pos = 0; pos < dupl_ustr[test_num].dest_buf_size/sizeof(WCHAR); pos++) {
 424                 dest_buf[pos] = dupl_ustr[test_num].dest_buf[pos];
 425             }
 426             dest_str.Buffer = dest_buf;
 427         } else {
 428             dest_str.Buffer = NULL;
 429         }
 430         res_str.Length        = dupl_ustr[test_num].res_Length;
 431         res_str.MaximumLength = dupl_ustr[test_num].res_MaximumLength;
 432         if (dupl_ustr[test_num].res_buf != NULL) {
 433             for (pos = 0; pos < dupl_ustr[test_num].res_buf_size/sizeof(WCHAR); pos++) {
 434                 res_buf[pos] = dupl_ustr[test_num].res_buf[pos];
 435             }
 436             res_str.Buffer = res_buf;
 437         } else {
 438             res_str.Buffer = NULL;
 439         }
 440         result = pRtlDuplicateUnicodeString(dupl_ustr[test_num].add_nul, &source_str, &dest_str);
 441         dest_ansi_str.Length = dest_str.Length / sizeof(WCHAR);
 442         dest_ansi_str.MaximumLength = dest_ansi_str.Length + 1;
 443         for (pos = 0; pos < dest_ansi_str.Length; pos++) {
 444             dest_ansi_buf[pos] = (char)dest_buf[pos];
 445         }
 446         dest_ansi_buf[dest_ansi_str.Length] = '\0';
 447         dest_ansi_str.Buffer = dest_ansi_buf;
 448         ok(result == dupl_ustr[test_num].result,
 449            "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has result %x, expected %x\n",
 450            test_num, dupl_ustr[test_num].add_nul, result, dupl_ustr[test_num].result);
 451         ok(dest_str.Length == dupl_ustr[test_num].res_Length,
 452            "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has Length %d, expected %d\n",
 453            test_num, dupl_ustr[test_num].add_nul, dest_str.Length, dupl_ustr[test_num].res_Length);
 454         ok(dest_str.MaximumLength == dupl_ustr[test_num].res_MaximumLength,
 455            "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination has MaximumLength %d, expected %d\n",
 456            test_num, dupl_ustr[test_num].add_nul, dest_str.MaximumLength, dupl_ustr[test_num].res_MaximumLength);
 457         if (result == STATUS_INVALID_PARAMETER) {
 458             ok((dest_str.Buffer == NULL && res_str.Buffer == NULL) ||
 459                dest_str.Buffer == dest_buf,
 460                "(test %d): RtlDuplicateUnicodeString(%d, source, dest) destination buffer changed %p expected %p\n",
 461                test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dest_buf);
 462         } else {
 463             ok(dest_str.Buffer != dest_buf,
 464                "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination buffer unchanged %p\n",
 465                test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer);
 466         }
 467         if (dest_str.Buffer != NULL && dupl_ustr[test_num].res_buf != NULL) {
 468             ok(memcmp(dest_str.Buffer, res_str.Buffer, dupl_ustr[test_num].res_buf_size) == 0,
 469                "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination \"%s\" expected \"%s\"\n",
 470                test_num, dupl_ustr[test_num].add_nul, dest_ansi_str.Buffer, dupl_ustr[test_num].res_buf);
 471             if(result == STATUS_SUCCESS) pRtlFreeUnicodeString(&dest_str);
 472         } else {
 473             ok(dest_str.Buffer == NULL && dupl_ustr[test_num].res_buf == NULL,
 474                "(test %d): RtlDuplicateUnicodeString(%d, source, dest) has destination %p expected %p\n",
 475                test_num, dupl_ustr[test_num].add_nul, dest_str.Buffer, dupl_ustr[test_num].res_buf);
 476         }
 477     }
 478 }
 479
 480
 481 static void test_RtlCopyString(void)
 482 {
 483     static const char teststring[] = "Some Wild String";
 484     char deststring[] = "                    ";
 485     STRING str;
 486     STRING deststr;
 487
 488     pRtlInitString(&str, teststring);
 489     pRtlInitString(&deststr, deststring);
 490     pRtlCopyString(&deststr, &str);
 491     ok(strncmp(str.Buffer, deststring, str.Length) == 0, "String not copied\n");
 492 }
 493
 494
 495 static void test_RtlUpperChar(void)
 496 {
 497     int ch;
 498     int upper_ch;
 499     int expected_upper_ch;
 500     int byte_ch;
 501
 502     for (ch = -1; ch <= 1024; ch++) {
 503         upper_ch = pRtlUpperChar(ch);
 504         byte_ch = ch & 0xff;
 505         if (byte_ch >= 'a' && byte_ch <= 'z') {
 506             expected_upper_ch = (CHAR) (byte_ch - 'a' + 'A');
 507         } else {
 508             expected_upper_ch = (CHAR) byte_ch;
 509         }
 510         ok(upper_ch == expected_upper_ch,
 511            "RtlUpperChar('%c'[=0x%x]) has result '%c'[=0x%x], expected '%c'[=0x%x]\n",
 512            ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
 513     }
 514 }
 515
 516
 517 static void test_RtlUpperString(void)
 518 {
 519     int i;
 520     CHAR ch;
 521     CHAR upper_ch;
 522     char ascii_buf[257];
 523     char result_buf[257];
 524     char upper_buf[257];
 525     STRING ascii_str;
 526     STRING result_str;
 527     STRING upper_str;
 528
 529     for (i = 0; i <= 255; i++) {
 530         ch = (CHAR) i;
 531         if (ch >= 'a' && ch <= 'z') {
 532             upper_ch = ch - 'a' + 'A';
 533         } else {
 534             upper_ch = ch;
 535         }
 536         ascii_buf[i] = ch;
 537         result_buf[i] = '\0';
 538         upper_buf[i] = upper_ch;
 539     }
 540     ascii_buf[i] = '\0';
 541     result_buf[i] = '\0';
 542     upper_buf[i] = '\0';
 543     ascii_str.Length = 256;
 544     ascii_str.MaximumLength = 256;
 545     ascii_str.Buffer = ascii_buf;
 546     result_str.Length = 256;
 547     result_str.MaximumLength = 256;
 548     result_str.Buffer = result_buf;
 549     upper_str.Length = 256;
 550     upper_str.MaximumLength = 256;
 551     upper_str.Buffer = upper_buf;
 552
 553     pRtlUpperString(&result_str, &ascii_str);
 554     ok(memcmp(result_str.Buffer, upper_str.Buffer, 256) == 0,
 555        "RtlUpperString does not work as expected\n");
 556 }
 557
 558
 559 static void test_RtlUpcaseUnicodeChar(void)
 560 {
 561     int i;
 562     WCHAR ch;
 563     WCHAR upper_ch;
 564     WCHAR expected_upper_ch;
 565
 566     for (i = 0; i <= 255; i++) {
 567         ch = (WCHAR) i;
 568         upper_ch = pRtlUpcaseUnicodeChar(ch);
 569         if (ch >= 'a' && ch <= 'z') {
 570             expected_upper_ch = ch - 'a' + 'A';
 571         } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) {
 572             expected_upper_ch = ch - 0x20;
 573         } else if (ch == 0xff) {
 574             expected_upper_ch = 0x178;
 575         } else {
 576             expected_upper_ch = ch;
 577         }
 578         ok(upper_ch == expected_upper_ch,
 579            "RtlUpcaseUnicodeChar('%c'[=0x%x]) has result '%c'[=0x%x], expected: '%c'[=0x%x]\n",
 580            ch, ch, upper_ch, upper_ch, expected_upper_ch, expected_upper_ch);
 581     }
 582 }
 583
 584
 585 static void test_RtlUpcaseUnicodeString(void)
 586 {
 587     int i;
 588     WCHAR ch;
 589     WCHAR upper_ch;
 590     WCHAR ascii_buf[257];
 591     WCHAR result_buf[257];
 592     WCHAR upper_buf[257];
 593     UNICODE_STRING ascii_str;
 594     UNICODE_STRING result_str;
 595     UNICODE_STRING upper_str;
 596
 597     for (i = 0; i <= 255; i++) {
 598         ch = (WCHAR) i;
 599         if (ch >= 'a' && ch <= 'z') {
 600             upper_ch = ch - 'a' + 'A';
 601         } else if (ch >= 0xe0 && ch <= 0xfe && ch != 0xf7) {
 602             upper_ch = ch - 0x20;
 603         } else if (ch == 0xff) {
 604             upper_ch = 0x178;
 605         } else {
 606             upper_ch = ch;
 607         }
 608         ascii_buf[i] = ch;
 609         result_buf[i] = '\0';
 610         upper_buf[i] = upper_ch;
 611     }
 612     ascii_buf[i] = '\0';
 613     result_buf[i] = '\0';
 614     upper_buf[i] = '\0';
 615     ascii_str.Length = 512;
 616     ascii_str.MaximumLength = 512;
 617     ascii_str.Buffer = ascii_buf;
 618     result_str.Length = 512;
 619     result_str.MaximumLength = 512;
 620     result_str.Buffer = result_buf;
 621     upper_str.Length = 512;
 622     upper_str.MaximumLength = 512;
 623     upper_str.Buffer = upper_buf;
 624
 625     pRtlUpcaseUnicodeString(&result_str, &ascii_str, 0);
 626     for (i = 0; i <= 255; i++) {
 627         ok(result_str.Buffer[i] == upper_str.Buffer[i],
 628            "RtlUpcaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
 629            ascii_str.Buffer[i], ascii_str.Buffer[i],
 630            result_str.Buffer[i], result_str.Buffer[i],
 631            upper_str.Buffer[i], upper_str.Buffer[i]);
 632     }
 633 }
 634
 635
 636 static void test_RtlDowncaseUnicodeString(void)
 637 {
 638     int i;
 639     WCHAR ch;
 640     WCHAR lower_ch;
 641     WCHAR source_buf[1025];
 642     WCHAR result_buf[1025];
 643     WCHAR lower_buf[1025];
 644     UNICODE_STRING source_str;
 645     UNICODE_STRING result_str;
 646     UNICODE_STRING lower_str;
 647
 648     for (i = 0; i < 1024; i++) {
 649         ch = (WCHAR) i;
 650         if (ch >= 'A' && ch <= 'Z') {
 651             lower_ch = ch - 'A' + 'a';
 652         } else if (ch >= 0xc0 && ch <= 0xde && ch != 0xd7) {
 653             lower_ch = ch + 0x20;
 654         } else if (ch >= 0x391 && ch <= 0x3ab && ch != 0x3a2) {
 655             lower_ch = ch + 0x20;
 656         } else {
 657             switch (ch) {
 658                 case 0x178: lower_ch = 0xff; break;
 659                 case 0x181: lower_ch = 0x253; break;
 660                 case 0x186: lower_ch = 0x254; break;
 661                 case 0x189: lower_ch = 0x256; break;
 662                 case 0x18a: lower_ch = 0x257; break;
 663                 case 0x18e: lower_ch = 0x1dd; break;
 664                 case 0x18f: lower_ch = 0x259; break;
 665                 case 0x190: lower_ch = 0x25b; break;
 666                 case 0x193: lower_ch = 0x260; break;
 667                 case 0x194: lower_ch = 0x263; break;
 668                 case 0x196: lower_ch = 0x269; break;
 669                 case 0x197: lower_ch = 0x268; break;
 670                 case 0x19c: lower_ch = 0x26f; break;
 671                 case 0x19d: lower_ch = 0x272; break;
 672                 case 0x19f: lower_ch = 0x275; break;
 673                 case 0x1a9: lower_ch = 0x283; break;
 674                 case 0x1ae: lower_ch = 0x288; break;
 675                 case 0x1b1: lower_ch = 0x28a; break;
 676                 case 0x1b2: lower_ch = 0x28b; break;
 677                 case 0x1b7: lower_ch = 0x292; break;
 678                 case 0x1c4: lower_ch = 0x1c6; break;
 679                 case 0x1c7: lower_ch = 0x1c9; break;
 680                 case 0x1ca: lower_ch = 0x1cc; break;
 681                 case 0x1f1: lower_ch = 0x1f3; break;
 682                 case 0x386: lower_ch = 0x3ac; break;
 683                 case 0x388: lower_ch = 0x3ad; break;
 684                 case 0x389: lower_ch = 0x3ae; break;
 685                 case 0x38a: lower_ch = 0x3af; break;
 686                 case 0x38c: lower_ch = 0x3cc; break;
 687                 case 0x38e: lower_ch = 0x3cd; break;
 688                 case 0x38f: lower_ch = 0x3ce; break;
 689                 default: lower_ch = ch; break;
 690             } /* switch */
 691         }
 692         source_buf[i] = ch;
 693         result_buf[i] = '\0';
 694         lower_buf[i] = lower_ch;
 695     }
 696     source_buf[i] = '\0';
 697     result_buf[i] = '\0';
 698     lower_buf[i] = '\0';
 699     source_str.Length = 2048;
 700     source_str.MaximumLength = 2048;
 701     source_str.Buffer = source_buf;
 702     result_str.Length = 2048;
 703     result_str.MaximumLength = 2048;
 704     result_str.Buffer = result_buf;
 705     lower_str.Length = 2048;
 706     lower_str.MaximumLength = 2048;
 707     lower_str.Buffer = lower_buf;
 708
 709     pRtlDowncaseUnicodeString(&result_str, &source_str, 0);
 710     for (i = 0; i <= 1024; i++) {
 711         ok(result_str.Buffer[i] == lower_str.Buffer[i] || result_str.Buffer[i] == source_str.Buffer[i] + 1,
 712            "RtlDowncaseUnicodeString works wrong: '%c'[=0x%x] is converted to '%c'[=0x%x], expected: '%c'[=0x%x]\n",
 713            source_str.Buffer[i], source_str.Buffer[i],
 714            result_str.Buffer[i], result_str.Buffer[i],
 715            lower_str.Buffer[i], lower_str.Buffer[i]);
 716     }
 717 }
 718
 719
 720 typedef struct {
 721     int ansi_Length;
 722     int ansi_MaximumLength;
 723     int ansi_buf_size;
 724     const char *ansi_buf;
 725     int uni_Length;
 726     int uni_MaximumLength;
 727     int uni_buf_size;
 728     const char *uni_buf;
 729     BOOLEAN doalloc;
 730     int res_Length;
 731     int res_MaximumLength;
 732     int res_buf_size;
 733     const char *res_buf;
 734     NTSTATUS result;
 735 } ustr2astr_t;
 736
 737 static const ustr2astr_t ustr2astr[] = {
 738     { 10, 12, 12, "------------",  0,  0,  0, "",       TRUE,  0, 1, 1, "",       STATUS_SUCCESS},
 739     { 10, 12, 12, "------------", 12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
 740     {  0,  2, 12, "------------", 12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
 741     { 10, 12, 12, NULL,           12, 12, 12, "abcdef", TRUE,  6, 7, 7, "abcdef", STATUS_SUCCESS},
 742     {  0,  0, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 0, 0, "",       STATUS_BUFFER_OVERFLOW},
 743     {  0,  1, 12, "------------", 12, 12, 12, "abcdef", FALSE, 0, 1, 1, "",       STATUS_BUFFER_OVERFLOW},
 744     {  0,  2, 12, "------------", 12, 12, 12, "abcdef", FALSE, 1, 2, 2, "a",      STATUS_BUFFER_OVERFLOW},
 745     {  0,  3, 12, "------------", 12, 12, 12, "abcdef", FALSE, 2, 3, 3, "ab",     STATUS_BUFFER_OVERFLOW},
 746     {  0,  5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd",   STATUS_BUFFER_OVERFLOW},
 747     {  8,  5, 12, "------------", 12, 12, 12, "abcdef", FALSE, 4, 5, 5, "abcd",   STATUS_BUFFER_OVERFLOW},
 748     {  8,  6, 12, "------------", 12, 12, 12, "abcdef", FALSE, 5, 6, 6, "abcde",  STATUS_BUFFER_OVERFLOW},
 749     {  8,  7, 12, "------------", 12, 12, 12, "abcdef", FALSE, 6, 7, 7, "abcdef", STATUS_SUCCESS},
 750     {  8,  7, 12, "------------",  0, 12, 12,  NULL,    FALSE, 0, 7, 0, "",       STATUS_SUCCESS},
 751 #if 0
 752     /* crashes on Japanese and Chinese XP */
 753     {  0,  0, 12, NULL,           10, 10, 12,  NULL,    FALSE, 5, 0, 0, NULL,     STATUS_BUFFER_OVERFLOW},
 754 #endif
 755 };
 756 #define NB_USTR2ASTR (sizeof(ustr2astr)/sizeof(*ustr2astr))
 757
 758
 759 static void test_RtlUnicodeStringToAnsiString(void)
 760 {
 761     size_t pos;
 762     CHAR ansi_buf[257];
 763     WCHAR uni_buf[257];
 764     STRING ansi_str;
 765     UNICODE_STRING uni_str;
 766     NTSTATUS result;
 767     unsigned int test_num;
 768
 769     for (test_num = 0; test_num < NB_USTR2ASTR; test_num++) {
 770         ansi_str.Length        = ustr2astr[test_num].ansi_Length;
 771         ansi_str.MaximumLength = ustr2astr[test_num].ansi_MaximumLength;
 772         if (ustr2astr[test_num].ansi_buf != NULL) {
 773             memcpy(ansi_buf, ustr2astr[test_num].ansi_buf, ustr2astr[test_num].ansi_buf_size);
 774             ansi_buf[ustr2astr[test_num].ansi_buf_size] = '\0';
 775             ansi_str.Buffer = ansi_buf;
 776         } else {
 777             ansi_str.Buffer = NULL;
 778         }
 779         uni_str.Length        = ustr2astr[test_num].uni_Length;
 780         uni_str.MaximumLength = ustr2astr[test_num].uni_MaximumLength;
 781         if (ustr2astr[test_num].uni_buf != NULL) {
 782             for (pos = 0; pos < ustr2astr[test_num].uni_buf_size/sizeof(WCHAR); pos++) {
 783                 uni_buf[pos] = ustr2astr[test_num].uni_buf[pos];
 784             }
 785             uni_str.Buffer = uni_buf;
 786         } else {
 787             uni_str.Buffer = NULL;
 788         }
 789         result = pRtlUnicodeStringToAnsiString(&ansi_str, &uni_str, ustr2astr[test_num].doalloc);
 790         ok(result == ustr2astr[test_num].result,
 791            "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has result %x, expected %x\n",
 792            test_num, ustr2astr[test_num].doalloc, result, ustr2astr[test_num].result);
 793         ok(ansi_str.Length == ustr2astr[test_num].res_Length,
 794            "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has Length %d, expected %d\n",
 795            test_num, ustr2astr[test_num].doalloc, ansi_str.Length, ustr2astr[test_num].res_Length);
 796         ok(ansi_str.MaximumLength == ustr2astr[test_num].res_MaximumLength,
 797            "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) ansi has MaximumLength %d, expected %d\n",
 798            test_num, ustr2astr[test_num].doalloc, ansi_str.MaximumLength, ustr2astr[test_num].res_MaximumLength);
 799         ok(memcmp(ansi_str.Buffer, ustr2astr[test_num].res_buf, ustr2astr[test_num].res_buf_size) == 0,
 800            "(test %d): RtlUnicodeStringToAnsiString(ansi, uni, %d) has ansi \"%s\" expected \"%s\"\n",
 801            test_num, ustr2astr[test_num].doalloc, ansi_str.Buffer, ustr2astr[test_num].res_buf);
 802         if(result == STATUS_SUCCESS && ustr2astr[test_num].doalloc)
 803             pRtlFreeAnsiString(&ansi_str);
 804     }
 805 }
 806
 807
 808 typedef struct {
 809     int dest_Length;
 810     int dest_MaximumLength;
 811     int dest_buf_size;
 812     const char *dest_buf;
 813     const char *src;
 814     int res_Length;
 815     int res_MaximumLength;
 816     int res_buf_size;
 817     const char *res_buf;
 818     NTSTATUS result;
 819 } app_asc2str_t;
 820
 821 static const app_asc2str_t app_asc2str[] = {
 822     { 5, 12, 15,  "TestS01234abcde", "tring", 10, 12, 15,  "TestStringabcde", STATUS_SUCCESS},
 823     { 5, 11, 15,  "TestS01234abcde", "tring", 10, 11, 15,  "TestStringabcde", STATUS_SUCCESS},
 824     { 5, 10, 15,  "TestS01234abcde", "tring", 10, 10, 15,  "TestStringabcde", STATUS_SUCCESS},
 825     { 5,  9, 15,  "TestS01234abcde", "tring",  5,  9, 15,  "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
 826     { 5,  0, 15,  "TestS01234abcde", "tring",  5,  0, 15,  "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
 827     { 5, 14, 15,  "TestS01234abcde", "tring", 10, 14, 15,  "TestStringabcde", STATUS_SUCCESS},
 828     { 5, 14, 15,  "TestS01234abcde",    NULL,  5, 14, 15,  "TestS01234abcde", STATUS_SUCCESS},
 829     { 5, 14, 15,               NULL,    NULL,  5, 14, 15,               NULL, STATUS_SUCCESS},
 830     { 5, 12, 15, "Tst\0S01234abcde", "tr\0i",  7, 12, 15, "Tst\0Str234abcde", STATUS_SUCCESS},
 831 };
 832 #define NB_APP_ASC2STR (sizeof(app_asc2str)/sizeof(*app_asc2str))
 833
 834
 835 static void test_RtlAppendAsciizToString(void)
 836 {
 837     CHAR dest_buf[257];
 838     STRING dest_str;
 839     NTSTATUS result;
 840     unsigned int test_num;
 841
 842     for (test_num = 0; test_num < NB_APP_ASC2STR; test_num++) {
 843         dest_str.Length        = app_asc2str[test_num].dest_Length;
 844         dest_str.MaximumLength = app_asc2str[test_num].dest_MaximumLength;
 845         if (app_asc2str[test_num].dest_buf != NULL) {
 846             memcpy(dest_buf, app_asc2str[test_num].dest_buf, app_asc2str[test_num].dest_buf_size);
 847             dest_buf[app_asc2str[test_num].dest_buf_size] = '\0';
 848             dest_str.Buffer = dest_buf;
 849         } else {
 850             dest_str.Buffer = NULL;
 851         }
 852         result = pRtlAppendAsciizToString(&dest_str, app_asc2str[test_num].src);
 853         ok(result == app_asc2str[test_num].result,
 854            "(test %d): RtlAppendAsciizToString(dest, src) has result %x, expected %x\n",
 855            test_num, result, app_asc2str[test_num].result);
 856         ok(dest_str.Length == app_asc2str[test_num].res_Length,
 857            "(test %d): RtlAppendAsciizToString(dest, src) dest has Length %d, expected %d\n",
 858            test_num, dest_str.Length, app_asc2str[test_num].res_Length);
 859         ok(dest_str.MaximumLength == app_asc2str[test_num].res_MaximumLength,
 860            "(test %d): RtlAppendAsciizToString(dest, src) dest has MaximumLength %d, expected %d\n",
 861            test_num, dest_str.MaximumLength, app_asc2str[test_num].res_MaximumLength);
 862         if (dest_str.Buffer == dest_buf) {
 863             ok(memcmp(dest_buf, app_asc2str[test_num].res_buf, app_asc2str[test_num].res_buf_size) == 0,
 864                "(test %d): RtlAppendAsciizToString(dest, src) has dest \"%s\" expected \"%s\"\n",
 865                test_num, dest_buf, app_asc2str[test_num].res_buf);
 866         } else {
 867             ok(dest_str.Buffer == app_asc2str[test_num].res_buf,
 868                "(test %d): RtlAppendAsciizToString(dest, src) dest has Buffer %p expected %p\n",
 869                test_num, dest_str.Buffer, app_asc2str[test_num].res_buf);
 870         }
 871     }
 872 }
 873
 874
 875 typedef struct {
 876     int dest_Length;
 877     int dest_MaximumLength;
 878     int dest_buf_size;
 879     const char *dest_buf;
 880     int src_Length;
 881     int src_MaximumLength;
 882     int src_buf_size;
 883     const char *src_buf;
 884     int res_Length;
 885     int res_MaximumLength;
 886     int res_buf_size;
 887     const char *res_buf;
 888     NTSTATUS result;
 889 } app_str2str_t;
 890
 891 static const app_str2str_t app_str2str[] = {
 892     { 5, 12, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 12, 15,   "TestStringabcde", STATUS_SUCCESS},
 893     { 5, 11, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 11, 15,   "TestStringabcde", STATUS_SUCCESS},
 894     { 5, 10, 15,  "TestS01234abcde", 5, 5, 7, "tringZY", 10, 10, 15,   "TestStringabcde", STATUS_SUCCESS},
 895     { 5,  9, 15,  "TestS01234abcde", 5, 5, 7, "tringZY",  5,  9, 15,   "TestS01234abcde", STATUS_BUFFER_TOO_SMALL},
 896     { 5,  0, 15,  "TestS01234abcde", 0, 0, 7, "tringZY",  5,  0, 15,   "TestS01234abcde", STATUS_SUCCESS},
 897     { 5, 14, 15,  "TestS01234abcde", 0, 0, 7, "tringZY",  5, 14, 15,   "TestS01234abcde", STATUS_SUCCESS},
 898     { 5, 14, 15,  "TestS01234abcde", 0, 0, 7,      NULL,  5, 14, 15,   "TestS01234abcde", STATUS_SUCCESS},
 899     { 5, 14, 15,               NULL, 0, 0, 7,      NULL,  5, 14, 15,                NULL, STATUS_SUCCESS},
 900     { 5, 12, 15, "Tst\0S01234abcde", 4, 4, 7, "tr\0iZY",  9, 12, 15, "Tst\0Str\0i4abcde", STATUS_SUCCESS},
 901 };
 902 #define NB_APP_STR2STR (sizeof(app_str2str)/sizeof(*app_str2str))
 903
 904
 905 static void test_RtlAppendStringToString(void)
 906 {
 907     CHAR dest_buf[257];
 908     CHAR src_buf[257];
 909     STRING dest_str;
 910     STRING src_str;
 911     NTSTATUS result;
 912     unsigned int test_num;
 913
 914     for (test_num = 0; test_num < NB_APP_STR2STR; test_num++) {
 915         dest_str.Length        = app_str2str[test_num].dest_Length;
 916         dest_str.MaximumLength = app_str2str[test_num].dest_MaximumLength;
 917         if (app_str2str[test_num].dest_buf != NULL) {
 918             memcpy(dest_buf, app_str2str[test_num].dest_buf, app_str2str[test_num].dest_buf_size);
 919             dest_buf[app_str2str[test_num].dest_buf_size] = '\0';
 920             dest_str.Buffer = dest_buf;
 921         } else {
 922             dest_str.Buffer = NULL;
 923         }
 924         src_str.Length         = app_str2str[test_num].src_Length;
 925         src_str.MaximumLength  = app_str2str[test_num].src_MaximumLength;
 926         if (app_str2str[test_num].src_buf != NULL) {
 927             memcpy(src_buf, app_str2str[test_num].src_buf, app_str2str[test_num].src_buf_size);
 928             src_buf[app_str2str[test_num].src_buf_size] = '\0';
 929             src_str.Buffer = src_buf;
 930         } else {
 931             src_str.Buffer = NULL;
 932         }
 933         result = pRtlAppendStringToString(&dest_str, &src_str);
 934         ok(result == app_str2str[test_num].result,
 935            "(test %d): RtlAppendStringToString(dest, src) has result %x, expected %x\n",
 936            test_num, result, app_str2str[test_num].result);
 937         ok(dest_str.Length == app_str2str[test_num].res_Length,
 938            "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
 939            test_num, dest_str.Length, app_str2str[test_num].res_Length);
 940         ok(dest_str.MaximumLength == app_str2str[test_num].res_MaximumLength,
 941            "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
 942            test_num, dest_str.MaximumLength, app_str2str[test_num].res_MaximumLength);
 943         if (dest_str.Buffer == dest_buf) {
 944             ok(memcmp(dest_buf, app_str2str[test_num].res_buf, app_str2str[test_num].res_buf_size) == 0,
 945                "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
 946                test_num, dest_buf, app_str2str[test_num].res_buf);
 947         } else {
 948             ok(dest_str.Buffer == app_str2str[test_num].res_buf,
 949                "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
 950                test_num, dest_str.Buffer, app_str2str[test_num].res_buf);
 951         }
 952     }
 953 }
 954
 955
 956 typedef struct {
 957     int dest_Length;
 958     int dest_MaximumLength;
 959     int dest_buf_size;
 960     const char *dest_buf;
 961     const char *src;
 962     int res_Length;
 963     int res_MaximumLength;
 964     int res_buf_size;
 965     const char *res_buf;
 966     NTSTATUS result;
 967 } app_uni2str_t;
 968
 969 static const app_uni2str_t app_uni2str[] = {
 970     { 4, 12, 14,     "Fake0123abcdef",    "Ustr\0",  8, 12, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
 971     { 4, 11, 14,     "Fake0123abcdef",    "Ustr\0",  8, 11, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
 972     { 4, 10, 14,     "Fake0123abcdef",    "Ustr\0",  8, 10, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
 973 /* In the following test the native function writes beyond MaximumLength
 974  *  { 4,  9, 14,     "Fake0123abcdef",    "Ustr\0",  8,  9, 14,    "FakeUstrabcdef", STATUS_SUCCESS},
 975  */
 976     { 4,  8, 14,     "Fake0123abcdef",    "Ustr\0",  8,  8, 14,    "FakeUstrabcdef", STATUS_SUCCESS},
 977     { 4,  7, 14,     "Fake0123abcdef",    "Ustr\0",  4,  7, 14,    "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
 978     { 4,  0, 14,     "Fake0123abcdef",    "Ustr\0",  4,  0, 14,    "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
 979     { 4, 14, 14,     "Fake0123abcdef",    "Ustr\0",  8, 14, 14,  "FakeUstr\0\0cdef", STATUS_SUCCESS},
 980     { 4, 14, 14,     "Fake0123abcdef",        NULL,  4, 14, 14,    "Fake0123abcdef", STATUS_SUCCESS},
 981     { 4, 14, 14,                 NULL,        NULL,  4, 14, 14,                NULL, STATUS_SUCCESS},
 982     { 4, 14, 14,     "Fake0123abcdef", "U\0stri\0", 10, 14, 14, "FakeU\0stri\0\0ef", STATUS_SUCCESS},
 983     { 6, 14, 16, "Te\0\0stabcdefghij",  "St\0\0ri",  8, 14, 16, "Te\0\0stSt\0\0efghij", STATUS_SUCCESS},
 984 };
 985 #define NB_APP_UNI2STR (sizeof(app_uni2str)/sizeof(*app_uni2str))
 986
 987
 988 static void test_RtlAppendUnicodeToString(void)
 989 {
 990     WCHAR dest_buf[257];
 991     UNICODE_STRING dest_str;
 992     NTSTATUS result;
 993     unsigned int test_num;
 994
 995     for (test_num = 0; test_num < NB_APP_UNI2STR; test_num++) {
 996         dest_str.Length        = app_uni2str[test_num].dest_Length;
 997         dest_str.MaximumLength = app_uni2str[test_num].dest_MaximumLength;
 998         if (app_uni2str[test_num].dest_buf != NULL) {
 999             memcpy(dest_buf, app_uni2str[test_num].dest_buf, app_uni2str[test_num].dest_buf_size);
1000             dest_buf[app_uni2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0';
1001             dest_str.Buffer = dest_buf;
1002         } else {
1003             dest_str.Buffer = NULL;
1004         }
1005         result = pRtlAppendUnicodeToString(&dest_str, (LPCWSTR) app_uni2str[test_num].src);
1006         ok(result == app_uni2str[test_num].result,
1007            "(test %d): RtlAppendUnicodeToString(dest, src) has result %x, expected %x\n",
1008            test_num, result, app_uni2str[test_num].result);
1009         ok(dest_str.Length == app_uni2str[test_num].res_Length,
1010            "(test %d): RtlAppendUnicodeToString(dest, src) dest has Length %d, expected %d\n",
1011            test_num, dest_str.Length, app_uni2str[test_num].res_Length);
1012         ok(dest_str.MaximumLength == app_uni2str[test_num].res_MaximumLength,
1013            "(test %d): RtlAppendUnicodeToString(dest, src) dest has MaximumLength %d, expected %d\n",
1014            test_num, dest_str.MaximumLength, app_uni2str[test_num].res_MaximumLength);
1015         if (dest_str.Buffer == dest_buf) {
1016             ok(memcmp(dest_buf, app_uni2str[test_num].res_buf, app_uni2str[test_num].res_buf_size) == 0,
1017                "(test %d): RtlAppendUnicodeToString(dest, src) has dest \"%s\" expected \"%s\"\n",
1018                test_num, (char *) dest_buf, app_uni2str[test_num].res_buf);
1019         } else {
1020             ok(dest_str.Buffer == (WCHAR *) app_uni2str[test_num].res_buf,
1021                "(test %d): RtlAppendUnicodeToString(dest, src) dest has Buffer %p expected %p\n",
1022                test_num, dest_str.Buffer, app_uni2str[test_num].res_buf);
1023         }
1024     }
1025 }
1026
1027
1028 typedef struct {
1029     int dest_Length;
1030     int dest_MaximumLength;
1031     int dest_buf_size;
1032     const char *dest_buf;
1033     int src_Length;
1034     int src_MaximumLength;
1035     int src_buf_size;
1036     const char *src_buf;
1037     int res_Length;
1038     int res_MaximumLength;
1039     int res_buf_size;
1040     const char *res_buf;
1041     NTSTATUS result;
1042 } app_ustr2str_t;
1043
1044 static const app_ustr2str_t app_ustr2str[] = {
1045     { 4, 12, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 12, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
1046     { 4, 11, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 11, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
1047     { 4, 10, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8, 10, 14,   "FakeUstr\0\0cdef", STATUS_SUCCESS},
1048 /* In the following test the native function writes beyond MaximumLength
1049  *  { 4,  9, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8,  9, 14,     "FakeUstrabcdef", STATUS_SUCCESS},
1050  */
1051     { 4,  8, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  8,  8, 14,     "FakeUstrabcdef", STATUS_SUCCESS},
1052     { 4,  7, 14,     "Fake0123abcdef", 4, 6, 8,   "UstrZYXW",  4,  7, 14,     "Fake0123abcdef", STATUS_BUFFER_TOO_SMALL},
1053     { 4,  0, 14,     "Fake0123abcdef", 0, 0, 8,   "UstrZYXW",  4,  0, 14,     "Fake0123abcdef", STATUS_SUCCESS},
1054     { 4, 14, 14,     "Fake0123abcdef", 0, 0, 8,   "UstrZYXW",  4, 14, 14,     "Fake0123abcdef", STATUS_SUCCESS},
1055     { 4, 14, 14,     "Fake0123abcdef", 0, 0, 8,         NULL,  4, 14, 14,     "Fake0123abcdef", STATUS_SUCCESS},
1056     { 4, 14, 14,                 NULL, 0, 0, 8,         NULL,  4, 14, 14,                 NULL, STATUS_SUCCESS},
1057     { 6, 14, 16, "Te\0\0stabcdefghij", 6, 8, 8, "St\0\0riZY", 12, 14, 16, "Te\0\0stSt\0\0ri\0\0ij", STATUS_SUCCESS},
1058 };
1059 #define NB_APP_USTR2STR (sizeof(app_ustr2str)/sizeof(*app_ustr2str))
1060
1061
1062 static void test_RtlAppendUnicodeStringToString(void)
1063 {
1064     WCHAR dest_buf[257];
1065     WCHAR src_buf[257];
1066     UNICODE_STRING dest_str;
1067     UNICODE_STRING src_str;
1068     NTSTATUS result;
1069     unsigned int test_num;
1070
1071     for (test_num = 0; test_num < NB_APP_USTR2STR; test_num++) {
1072         dest_str.Length        = app_ustr2str[test_num].dest_Length;
1073         dest_str.MaximumLength = app_ustr2str[test_num].dest_MaximumLength;
1074         if (app_ustr2str[test_num].dest_buf != NULL) {
1075             memcpy(dest_buf, app_ustr2str[test_num].dest_buf, app_ustr2str[test_num].dest_buf_size);
1076             dest_buf[app_ustr2str[test_num].dest_buf_size/sizeof(WCHAR)] = '\0';
1077             dest_str.Buffer = dest_buf;
1078         } else {
1079             dest_str.Buffer = NULL;
1080         }
1081         src_str.Length         = app_ustr2str[test_num].src_Length;
1082         src_str.MaximumLength  = app_ustr2str[test_num].src_MaximumLength;
1083         if (app_ustr2str[test_num].src_buf != NULL) {
1084             memcpy(src_buf, app_ustr2str[test_num].src_buf, app_ustr2str[test_num].src_buf_size);
1085             src_buf[app_ustr2str[test_num].src_buf_size/sizeof(WCHAR)] = '\0';
1086             src_str.Buffer = src_buf;
1087         } else {
1088             src_str.Buffer = NULL;
1089         }
1090         result = pRtlAppendUnicodeStringToString(&dest_str, &src_str);
1091         ok(result == app_ustr2str[test_num].result,
1092            "(test %d): RtlAppendStringToString(dest, src) has result %x, expected %x\n",
1093            test_num, result, app_ustr2str[test_num].result);
1094         ok(dest_str.Length == app_ustr2str[test_num].res_Length,
1095            "(test %d): RtlAppendStringToString(dest, src) dest has Length %d, expected %d\n",
1096            test_num, dest_str.Length, app_ustr2str[test_num].res_Length);
1097         ok(dest_str.MaximumLength == app_ustr2str[test_num].res_MaximumLength,
1098            "(test %d): RtlAppendStringToString(dest, src) dest has MaximumLength %d, expected %d\n",
1099            test_num, dest_str.MaximumLength, app_ustr2str[test_num].res_MaximumLength);
1100         if (dest_str.Buffer == dest_buf) {
1101             ok(memcmp(dest_buf, app_ustr2str[test_num].res_buf, app_ustr2str[test_num].res_buf_size) == 0,
1102                "(test %d): RtlAppendStringToString(dest, src) has dest \"%s\" expected \"%s\"\n",
1103                test_num, (char *) dest_buf, app_ustr2str[test_num].res_buf);
1104         } else {
1105             ok(dest_str.Buffer == (WCHAR *) app_ustr2str[test_num].res_buf,
1106                "(test %d): RtlAppendStringToString(dest, src) dest has Buffer %p expected %p\n",
1107                test_num, dest_str.Buffer, app_ustr2str[test_num].res_buf);
1108         }
1109     }
1110 }
1111
1112
1113 typedef struct {
1114     int flags;
1115     const char *main_str;
1116     const char *search_chars;
1117     USHORT pos;
1118     NTSTATUS result;
1119 } find_ch_in_ustr_t;
1120
1121 static const find_ch_in_ustr_t find_ch_in_ustr[] = {
1122     { 0, "Some Wild String",           "S",       2, STATUS_SUCCESS},
1123     { 0, "This is a String",           "String",  6, STATUS_SUCCESS},
1124     { 1, "This is a String",           "String", 30, STATUS_SUCCESS},
1125     { 2, "This is a String",           "String",  2, STATUS_SUCCESS},
1126     { 3, "This is a String",           "String", 18, STATUS_SUCCESS},
1127     { 0, "This is a String",           "Wild",    6, STATUS_SUCCESS},
1128     { 1, "This is a String",           "Wild",   26, STATUS_SUCCESS},
1129     { 2, "This is a String",           "Wild",    2, STATUS_SUCCESS},
1130     { 3, "This is a String",           "Wild",   30, STATUS_SUCCESS},
1131     { 0, "abcdefghijklmnopqrstuvwxyz", "",        0, STATUS_NOT_FOUND},
1132     { 0, "abcdefghijklmnopqrstuvwxyz", "123",     0, STATUS_NOT_FOUND},
1133     { 0, "abcdefghijklmnopqrstuvwxyz", "a",       2, STATUS_SUCCESS},
1134     { 0, "abcdefghijklmnopqrstuvwxyz", "12a34",   2, STATUS_SUCCESS},
1135     { 0, "abcdefghijklmnopqrstuvwxyz", "12b34",   4, STATUS_SUCCESS},
1136     { 0, "abcdefghijklmnopqrstuvwxyz", "12y34",  50, STATUS_SUCCESS},
1137     { 0, "abcdefghijklmnopqrstuvwxyz", "12z34",  52, STATUS_SUCCESS},
1138     { 0, "abcdefghijklmnopqrstuvwxyz", "rvz",    36, STATUS_SUCCESS},
1139     { 0, "abcdefghijklmmlkjihgfedcba", "egik",   10, STATUS_SUCCESS},
1140     { 1, "abcdefghijklmnopqrstuvwxyz", "",        0, STATUS_NOT_FOUND},
1141     { 1, "abcdefghijklmnopqrstuvwxyz", "rvz",    50, STATUS_SUCCESS},
1142     { 1, "abcdefghijklmnopqrstuvwxyz", "ravy",   48, STATUS_SUCCESS},
1143     { 1, "abcdefghijklmnopqrstuvwxyz", "raxv",   46, STATUS_SUCCESS},
1144     { 2, "abcdefghijklmnopqrstuvwxyz", "",        2, STATUS_SUCCESS},
1145     { 2, "abcdefghijklmnopqrstuvwxyz", "rvz",     2, STATUS_SUCCESS},
1146     { 2, "abcdefghijklmnopqrstuvwxyz", "vaz",     4, STATUS_SUCCESS},
1147     { 2, "abcdefghijklmnopqrstuvwxyz", "ravbz",   6, STATUS_SUCCESS},
1148     { 3, "abcdefghijklmnopqrstuvwxyz", "",       50, STATUS_SUCCESS},
1149     { 3, "abcdefghijklmnopqrstuvwxyz", "123",    50, STATUS_SUCCESS},
1150     { 3, "abcdefghijklmnopqrstuvwxyz", "ahp",    50, STATUS_SUCCESS},
1151     { 3, "abcdefghijklmnopqrstuvwxyz", "rvz",    48, STATUS_SUCCESS},
1152     { 0, NULL,                         "abc",     0, STATUS_NOT_FOUND},
1153     { 1, NULL,                         "abc",     0, STATUS_NOT_FOUND},
1154     { 2, NULL,                         "abc",     0, STATUS_NOT_FOUND},
1155     { 3, NULL,                         "abc",     0, STATUS_NOT_FOUND},
1156     { 0, "abcdefghijklmnopqrstuvwxyz", NULL,      0, STATUS_NOT_FOUND},
1157     { 1, "abcdefghijklmnopqrstuvwxyz", NULL,      0, STATUS_NOT_FOUND},
1158     { 2, "abcdefghijklmnopqrstuvwxyz", NULL,      2, STATUS_SUCCESS},
1159     { 3, "abcdefghijklmnopqrstuvwxyz", NULL,     50, STATUS_SUCCESS},
1160     { 0, NULL,                         NULL,      0, STATUS_NOT_FOUND},
1161     { 1, NULL,                         NULL,      0, STATUS_NOT_FOUND},
1162     { 2, NULL,                         NULL,      0, STATUS_NOT_FOUND},
1163     { 3, NULL,                         NULL,      0, STATUS_NOT_FOUND},
1164     { 0, "abcdabcdabcdabcdabcdabcd",   "abcd",    2, STATUS_SUCCESS},
1165     { 1, "abcdabcdabcdabcdabcdabcd",   "abcd",   46, STATUS_SUCCESS},
1166     { 2, "abcdabcdabcdabcdabcdabcd",   "abcd",    0, STATUS_NOT_FOUND},
1167     { 3, "abcdabcdabcdabcdabcdabcd",   "abcd",    0, STATUS_NOT_FOUND},
1168 };
1169 #define NB_FIND_CH_IN_USTR (sizeof(find_ch_in_ustr)/sizeof(*find_ch_in_ustr))
1170
1171
1172 static void test_RtlFindCharInUnicodeString(void)
1173 {
1174     WCHAR main_str_buf[257];
1175     WCHAR search_chars_buf[257];
1176     UNICODE_STRING main_str;
1177     UNICODE_STRING search_chars;
1178     USHORT pos;
1179     NTSTATUS result;
1180     unsigned int idx;
1181     unsigned int test_num;
1182
1183     for (test_num = 0; test_num < NB_FIND_CH_IN_USTR; test_num++) {
1184         if (find_ch_in_ustr[test_num].main_str != NULL) {
1185             main_str.Length        = strlen(find_ch_in_ustr[test_num].main_str) * sizeof(WCHAR);
1186             main_str.MaximumLength = main_str.Length + sizeof(WCHAR);
1187             for (idx = 0; idx < main_str.Length / sizeof(WCHAR); idx++) {
1188                 main_str_buf[idx] = find_ch_in_ustr[test_num].main_str[idx];
1189             }
1190             main_str.Buffer = main_str_buf;
1191         } else {
1192             main_str.Length        = 0;
1193             main_str.MaximumLength = 0;
1194             main_str.Buffer        = NULL;
1195         }
1196         if (find_ch_in_ustr[test_num].search_chars != NULL) {
1197             search_chars.Length        = strlen(find_ch_in_ustr[test_num].search_chars) * sizeof(WCHAR);
1198             search_chars.MaximumLength = search_chars.Length + sizeof(WCHAR);
1199             for (idx = 0; idx < search_chars.Length / sizeof(WCHAR); idx++) {
1200                 search_chars_buf[idx] = find_ch_in_ustr[test_num].search_chars[idx];
1201             }
1202             search_chars.Buffer = search_chars_buf;
1203         } else {
1204             search_chars.Length        = 0;
1205             search_chars.MaximumLength = 0;
1206             search_chars.Buffer        = NULL;
1207         }
1208         pos = 12345;
1209         result = pRtlFindCharInUnicodeString(find_ch_in_ustr[test_num].flags, &main_str, &search_chars, &pos);
1210         ok(result == find_ch_in_ustr[test_num].result,
1211            "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) has result %x, expected %x\n",
1212            test_num, find_ch_in_ustr[test_num].flags,
1213            find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
1214            result, find_ch_in_ustr[test_num].result);
1215         ok(pos == find_ch_in_ustr[test_num].pos,
1216            "(test %d): RtlFindCharInUnicodeString(%d, %s, %s, [out]) assigns %d to pos, expected %d\n",
1217            test_num, find_ch_in_ustr[test_num].flags,
1218            find_ch_in_ustr[test_num].main_str, find_ch_in_ustr[test_num].search_chars,
1219            pos, find_ch_in_ustr[test_num].pos);
1220     }
1221 }
1222
1223
1224 typedef struct {
1225     int base;
1226     const char *str;
1227     int value;
1228     NTSTATUS result, alternative;
1229 } str2int_t;
1230
1231 static const str2int_t str2int[] = {
1232     { 0, "1011101100",   1011101100, STATUS_SUCCESS},
1233     { 0, "1234567",         1234567, STATUS_SUCCESS},
1234     { 0, "-214",               -214, STATUS_SUCCESS},
1235     { 0, "+214",                214, STATUS_SUCCESS}, /* The + sign is allowed also */
1236     { 0, "--214",                 0, STATUS_SUCCESS}, /* Do not accept more than one sign */
1237     { 0, "-+214",                 0, STATUS_SUCCESS},
1238     { 0, "++214",                 0, STATUS_SUCCESS},
1239     { 0, "+-214",                 0, STATUS_SUCCESS},
1240     { 0, "\001\002\003\00411",   11, STATUS_SUCCESS}, /* whitespace char  1 to  4 */
1241     { 0, "\005\006\007\01012",   12, STATUS_SUCCESS}, /* whitespace char  5 to  8 */
1242     { 0, "\011\012\013\01413",   13, STATUS_SUCCESS}, /* whitespace char  9 to 12 */
1243     { 0, "\015\016\017\02014",   14, STATUS_SUCCESS}, /* whitespace char 13 to 16 */
1244     { 0, "\021\022\023\02415",   15, STATUS_SUCCESS}, /* whitespace char 17 to 20 */
1245     { 0, "\025\026\027\03016",   16, STATUS_SUCCESS}, /* whitespace char 21 to 24 */
1246     { 0, "\031\032\033\03417",   17, STATUS_SUCCESS}, /* whitespace char 25 to 28 */
1247     { 0, "\035\036\037\04018",   18, STATUS_SUCCESS}, /* whitespace char 29 to 32 */
1248     { 0, " \n \r \t214",        214, STATUS_SUCCESS},
1249     { 0, " \n \r \t+214",       214, STATUS_SUCCESS}, /* Signs can be used after whitespace */
1250     { 0, " \n \r \t-214",      -214, STATUS_SUCCESS},
1251     { 0, "+214 0",              214, STATUS_SUCCESS}, /* Space terminates the number */
1252     { 0, " 214.01",             214, STATUS_SUCCESS}, /* Decimal point not accepted */
1253     { 0, " 214,01",             214, STATUS_SUCCESS}, /* Decimal comma not accepted */
1254     { 0, "f81",                   0, STATUS_SUCCESS},
1255     { 0, "0x12345",         0x12345, STATUS_SUCCESS}, /* Hex */
1256     { 0, "00x12345",              0, STATUS_SUCCESS},
1257     { 0, "0xx12345",              0, STATUS_SUCCESS},
1258     { 0, "1x34",                  1, STATUS_SUCCESS},
1259     { 0, "-9999999999", -1410065407, STATUS_SUCCESS}, /* Big negative integer */
1260     { 0, "-2147483649",  2147483647, STATUS_SUCCESS}, /* Too small to fit in 32 Bits */
1261     { 0, "-2147483648", 0x80000000L, STATUS_SUCCESS}, /* Smallest negative integer */
1262     { 0, "-2147483647", -2147483647, STATUS_SUCCESS},
1263     { 0, "-1",                   -1, STATUS_SUCCESS},
1264     { 0, "0",                     0, STATUS_SUCCESS},
1265     { 0, "1",                     1, STATUS_SUCCESS},
1266     { 0, "2147483646",   2147483646, STATUS_SUCCESS},
1267     { 0, "2147483647",   2147483647, STATUS_SUCCESS}, /* Largest signed positive integer */
1268     { 0, "2147483648",  0x80000000L, STATUS_SUCCESS}, /* Positive int equal to smallest negative int */
1269     { 0, "2147483649",  -2147483647, STATUS_SUCCESS},
1270     { 0, "4294967294",           -2, STATUS_SUCCESS},
1271     { 0, "4294967295",           -1, STATUS_SUCCESS}, /* Largest unsigned integer */
1272     { 0, "4294967296",            0, STATUS_SUCCESS}, /* Too big to fit in 32 Bits */
1273     { 0, "9999999999",   1410065407, STATUS_SUCCESS}, /* Big positive integer */
1274     { 0, "056789",            56789, STATUS_SUCCESS}, /* Leading zero and still decimal */
1275     { 0, "b1011101100",           0, STATUS_SUCCESS}, /* Binary (b-notation) */
1276     { 0, "-b1011101100",          0, STATUS_SUCCESS}, /* Negative Binary (b-notation) */
1277     { 0, "b10123456789",          0, STATUS_SUCCESS}, /* Binary with nonbinary digits (2-9) */
1278     { 0, "0b1011101100",        748, STATUS_SUCCESS}, /* Binary (0b-notation) */
1279     { 0, "-0b1011101100",      -748, STATUS_SUCCESS}, /* Negative binary (0b-notation) */
1280     { 0, "0b10123456789",         5, STATUS_SUCCESS}, /* Binary with nonbinary digits (2-9) */
1281     { 0, "-0b10123456789",       -5, STATUS_SUCCESS}, /* Negative binary with nonbinary digits (2-9) */
1282     { 0, "0b1",                   1, STATUS_SUCCESS}, /* one digit binary */
1283     { 0, "0b2",                   0, STATUS_SUCCESS}, /* empty binary */
1284     { 0, "0b",                    0, STATUS_SUCCESS}, /* empty binary */
1285     { 0, "o1234567",              0, STATUS_SUCCESS}, /* Octal (o-notation) */
1286     { 0, "-o1234567",             0, STATUS_SUCCESS}, /* Negative Octal (o-notation) */
1287     { 0, "o56789",                0, STATUS_SUCCESS}, /* Octal with nonoctal digits (8 and 9) */
1288     { 0, "0o1234567",      01234567, STATUS_SUCCESS}, /* Octal (0o-notation) */
1289     { 0, "-0o1234567",    -01234567, STATUS_SUCCESS}, /* Negative octal (0o-notation) */
1290     { 0, "0o56789",            0567, STATUS_SUCCESS}, /* Octal with nonoctal digits (8 and 9) */
1291     { 0, "-0o56789",          -0567, STATUS_SUCCESS}, /* Negative octal with nonoctal digits (8 and 9) */
1292     { 0, "0o7",                   7, STATUS_SUCCESS}, /* one digit octal */
1293     { 0, "0o8",                   0, STATUS_SUCCESS}, /* empty octal */
1294     { 0, "0o",                    0, STATUS_SUCCESS}, /* empty octal */
1295     { 0, "0d1011101100",          0, STATUS_SUCCESS}, /* explicit decimal with 0d */
1296     { 0, "x89abcdef",             0, STATUS_SUCCESS}, /* Hex with lower case digits a-f (x-notation) */
1297     { 0, "xFEDCBA00",             0, STATUS_SUCCESS}, /* Hex with upper case digits A-F (x-notation) */
1298     { 0, "-xFEDCBA00",            0, STATUS_SUCCESS}, /* Negative Hexadecimal (x-notation) */
1299     { 0, "0x89abcdef",   0x89abcdef, STATUS_SUCCESS}, /* Hex with lower case digits a-f (0x-notation) */
1300     { 0, "0xFEDCBA00",   0xFEDCBA00, STATUS_SUCCESS}, /* Hex with upper case digits A-F (0x-notation) */
1301     { 0, "-0xFEDCBA00",    19088896, STATUS_SUCCESS}, /* Negative Hexadecimal (0x-notation) */
1302     { 0, "0xabcdefgh",     0xabcdef, STATUS_SUCCESS}, /* Hex with illegal lower case digits (g-z) */
1303     { 0, "0xABCDEFGH",     0xABCDEF, STATUS_SUCCESS}, /* Hex with illegal upper case digits (G-Z) */
1304     { 0, "0xF",                 0xf, STATUS_SUCCESS}, /* one digit hexadecimal */
1305     { 0, "0xG",                   0, STATUS_SUCCESS}, /* empty hexadecimal */
1306     { 0, "0x",                    0, STATUS_SUCCESS}, /* empty hexadecimal */
1307     { 0, "",                      0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
1308     { 2, "1011101100",          748, STATUS_SUCCESS},
1309     { 2, "-1011101100",        -748, STATUS_SUCCESS},
1310     { 2, "2",                     0, STATUS_SUCCESS},
1311     { 2, "0b1011101100",          0, STATUS_SUCCESS},
1312     { 2, "0o1011101100",          0, STATUS_SUCCESS},
1313     { 2, "0d1011101100",          0, STATUS_SUCCESS},
1314     { 2, "0x1011101100",          0, STATUS_SUCCESS},
1315     { 2, "",                      0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
1316     { 8, "1011101100",    136610368, STATUS_SUCCESS},
1317     { 8, "-1011101100",  -136610368, STATUS_SUCCESS},
1318     { 8, "8",                     0, STATUS_SUCCESS},
1319     { 8, "0b1011101100",          0, STATUS_SUCCESS},
1320     { 8, "0o1011101100",          0, STATUS_SUCCESS},
1321     { 8, "0d1011101100",          0, STATUS_SUCCESS},
1322     { 8, "0x1011101100",          0, STATUS_SUCCESS},
1323     { 8, "",                      0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
1324     {10, "1011101100",   1011101100, STATUS_SUCCESS},
1325     {10, "-1011101100", -1011101100, STATUS_SUCCESS},
1326     {10, "0b1011101100",          0, STATUS_SUCCESS},
1327     {10, "0o1011101100",          0, STATUS_SUCCESS},
1328     {10, "0d1011101100",          0, STATUS_SUCCESS},
1329     {10, "0x1011101100",          0, STATUS_SUCCESS},
1330     {10, "o12345",                0, STATUS_SUCCESS}, /* Octal although base is 10 */
1331     {10, "",                      0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
1332     {16, "1011101100",    286265600, STATUS_SUCCESS},
1333     {16, "-1011101100",  -286265600, STATUS_SUCCESS},
1334     {16, "G",                     0, STATUS_SUCCESS},
1335     {16, "g",                     0, STATUS_SUCCESS},
1336     {16, "0b1011101100",  286265600, STATUS_SUCCESS},
1337     {16, "0o1011101100",          0, STATUS_SUCCESS},
1338     {16, "0d1011101100",  286265600, STATUS_SUCCESS},
1339     {16, "0x1011101100",          0, STATUS_SUCCESS},
1340     {16, "",                      0, STATUS_SUCCESS, STATUS_INVALID_PARAMETER}, /* empty string */
1341     {20, "0",                     0, STATUS_INVALID_PARAMETER}, /* illegal base */
1342     {-8, "0",                     0, STATUS_INVALID_PARAMETER}, /* Negative base */
1343 /*    { 0, NULL,                    0, STATUS_SUCCESS}, */ /* NULL as string */
1344 };
1345 #define NB_STR2INT (sizeof(str2int)/sizeof(*str2int))
1346
1347
1348 static void test_RtlUnicodeStringToInteger(void)
1349 {
1350     unsigned int test_num;
1351     int value;
1352     NTSTATUS result;
1353     WCHAR *wstr;
1354     UNICODE_STRING uni;
1355
1356     for (test_num = 0; test_num < NB_STR2INT; test_num++) {
1357         wstr = AtoW(str2int[test_num].str);
1358         value = 0xdeadbeef;
1359         pRtlInitUnicodeString(&uni, wstr);
1360         result = pRtlUnicodeStringToInteger(&uni, str2int[test_num].base, &value);
1361         ok(result == str2int[test_num].result ||
1362            (str2int[test_num].alternative && result == str2int[test_num].alternative),
1363            "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n",
1364            test_num, str2int[test_num].str, str2int[test_num].base, result,
1365            str2int[test_num].result, str2int[test_num].alternative);
1366         if (result == STATUS_SUCCESS)
1367             ok(value == str2int[test_num].value ||
1368                broken(str2int[test_num].str[0] == '\0' && str2int[test_num].base == 16), /* nt4 */
1369                "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
1370                test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
1371         else
1372             ok(value == 0xdeadbeef || value == 0 /* vista */,
1373                "(test %d): RtlUnicodeStringToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
1374                test_num, str2int[test_num].str, str2int[test_num].base, value);
1375         HeapFree(GetProcessHeap(), 0, wstr);
1376     }
1377
1378     wstr = AtoW(str2int[1].str);
1379     pRtlInitUnicodeString(&uni, wstr);
1380     result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, NULL);
1381     ok(result == STATUS_ACCESS_VIOLATION,
1382        "call failed: RtlUnicodeStringToInteger(\"%s\", %d, NULL) has result %x\n",
1383        str2int[1].str, str2int[1].base, result);
1384     result = pRtlUnicodeStringToInteger(&uni, 20, NULL);
1385     ok(result == STATUS_INVALID_PARAMETER || result == STATUS_ACCESS_VIOLATION,
1386        "call failed: RtlUnicodeStringToInteger(\"%s\", 20, NULL) has result %x\n",
1387        str2int[1].str, result);
1388
1389     uni.Length = 10; /* Make Length shorter (5 WCHARS instead of 7) */
1390     result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
1391     ok(result == STATUS_SUCCESS,
1392        "call failed: RtlUnicodeStringToInteger(\"12345\", %d, [out]) has result %x\n",
1393        str2int[1].base, result);
1394     ok(value == 12345,
1395        "didn't return expected value (test a): expected: %d, got: %d\n",
1396        12345, value);
1397
1398     uni.Length = 5; /* Use odd Length (2.5 WCHARS) */
1399     result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
1400     ok(result == STATUS_SUCCESS || result == STATUS_INVALID_PARAMETER /* vista */,
1401        "call failed: RtlUnicodeStringToInteger(\"12\", %d, [out]) has result %x\n",
1402        str2int[1].base, result);
1403     if (result == STATUS_SUCCESS)
1404         ok(value == 12, "didn't return expected value (test b): expected: %d, got: %d\n", 12, value);
1405
1406     uni.Length = 2;
1407     result = pRtlUnicodeStringToInteger(&uni, str2int[1].base, &value);
1408     ok(result == STATUS_SUCCESS,
1409        "call failed: RtlUnicodeStringToInteger(\"1\", %d, [out]) has result %x\n",
1410        str2int[1].base, result);
1411     ok(value == 1,
1412        "didn't return expected value (test c): expected: %d, got: %d\n",
1413        1, value);
1414     /* w2k: uni.Length = 0 returns value 11234567 instead of 0 */
1415     HeapFree(GetProcessHeap(), 0, wstr);
1416 }
1417
1418
1419 static void test_RtlCharToInteger(void)
1420 {
1421     unsigned int test_num;
1422     int value;
1423     NTSTATUS result;
1424
1425     for (test_num = 0; test_num < NB_STR2INT; test_num++) {
1426         /* w2k skips a leading '\0' and processes the string after */
1427         if (str2int[test_num].str[0] != '\0') {
1428             value = 0xdeadbeef;
1429             result = pRtlCharToInteger(str2int[test_num].str, str2int[test_num].base, &value);
1430             ok(result == str2int[test_num].result ||
1431                (str2int[test_num].alternative && result == str2int[test_num].alternative),
1432                "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) has result %x, expected: %x (%x)\n",
1433                test_num, str2int[test_num].str, str2int[test_num].base, result,
1434                str2int[test_num].result, str2int[test_num].alternative);
1435             if (result == STATUS_SUCCESS)
1436                 ok(value == str2int[test_num].value,
1437                    "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected: %d\n",
1438                    test_num, str2int[test_num].str, str2int[test_num].base, value, str2int[test_num].value);
1439             else
1440                 ok(value == 0 || value == 0xdeadbeef,
1441                    "(test %d): call failed: RtlCharToInteger(\"%s\", %d, [out]) assigns value %d, expected 0 or deadbeef\n",
1442                    test_num, str2int[test_num].str, str2int[test_num].base, value);
1443         }
1444     }
1445
1446     result = pRtlCharToInteger(str2int[1].str, str2int[1].base, NULL);
1447     ok(result == STATUS_ACCESS_VIOLATION,
1448        "call failed: RtlCharToInteger(\"%s\", %d, NULL) has result %x\n",
1449        str2int[1].str, str2int[1].base, result);
1450
1451     result = pRtlCharToInteger(str2int[1].str, 20, NULL);
1452     ok(result == STATUS_INVALID_PARAMETER,
1453        "call failed: RtlCharToInteger(\"%s\", 20, NULL) has result %x\n",
1454        str2int[1].str, result);
1455 }
1456
1457
1458 #define STRI_BUFFER_LENGTH 35
1459
1460 typedef struct {
1461     int base;
1462     ULONG value;
1463     USHORT Length;
1464     USHORT MaximumLength;
1465     const char *Buffer;
1466     NTSTATUS result;
1467 } int2str_t;
1468
1469 static const int2str_t int2str[] = {
1470     {10,          123,  3, 11, "123\0-------------------------------", STATUS_SUCCESS},
1471
1472     { 0,  0x80000000U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* min signed int */
1473     { 0,  -2147483647, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS},
1474     { 0,           -2, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS},
1475     { 0,           -1, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS},
1476     { 0,            0,  1, 11, "0\0---------------------------------", STATUS_SUCCESS},
1477     { 0,            1,  1, 11, "1\0---------------------------------", STATUS_SUCCESS},
1478     { 0,           12,  2, 11, "12\0--------------------------------", STATUS_SUCCESS},
1479     { 0,          123,  3, 11, "123\0-------------------------------", STATUS_SUCCESS},
1480     { 0,         1234,  4, 11, "1234\0------------------------------", STATUS_SUCCESS},
1481     { 0,        12345,  5, 11, "12345\0-----------------------------", STATUS_SUCCESS},
1482     { 0,       123456,  6, 11, "123456\0----------------------------", STATUS_SUCCESS},
1483     { 0,      1234567,  7, 11, "1234567\0---------------------------", STATUS_SUCCESS},
1484     { 0,     12345678,  8, 11, "12345678\0--------------------------", STATUS_SUCCESS},
1485     { 0,    123456789,  9, 11, "123456789\0-------------------------", STATUS_SUCCESS},
1486     { 0,   2147483646, 10, 11, "2147483646\0------------------------", STATUS_SUCCESS},
1487     { 0,   2147483647, 10, 11, "2147483647\0------------------------", STATUS_SUCCESS}, /* max signed int */
1488     { 0,  2147483648U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* uint = -max int */
1489     { 0,  2147483649U, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS},
1490     { 0,  4294967294U, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS},
1491     { 0,  4294967295U, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, /* max unsigned int */
1492
1493     { 2,  0x80000000U, 32, 33, "10000000000000000000000000000000\0--", STATUS_SUCCESS}, /* min signed int */
1494     { 2,  -2147483647, 32, 33, "10000000000000000000000000000001\0--", STATUS_SUCCESS},
1495     { 2,           -2, 32, 33, "11111111111111111111111111111110\0--", STATUS_SUCCESS},
1496     { 2,           -1, 32, 33, "11111111111111111111111111111111\0--", STATUS_SUCCESS},
1497     { 2,            0,  1, 33, "0\0---------------------------------", STATUS_SUCCESS},
1498     { 2,            1,  1, 33, "1\0---------------------------------", STATUS_SUCCESS},
1499     { 2,           10,  4, 33, "1010\0------------------------------", STATUS_SUCCESS},
1500     { 2,          100,  7, 33, "1100100\0---------------------------", STATUS_SUCCESS},
1501     { 2,         1000, 10, 33, "1111101000\0------------------------", STATUS_SUCCESS},
1502     { 2,        10000, 14, 33, "10011100010000\0--------------------", STATUS_SUCCESS},
1503     { 2,        32767, 15, 33, "111111111111111\0-------------------", STATUS_SUCCESS},
1504 /*  { 2,        32768, 16, 33, "1000000000000000\0------------------", STATUS_SUCCESS}, broken on windows */
1505 /*  { 2,        65535, 16, 33, "1111111111111111\0------------------", STATUS_SUCCESS}, broken on windows */
1506     { 2,        65536, 17, 33, "10000000000000000\0-----------------", STATUS_SUCCESS},
1507     { 2,       100000, 17, 33, "11000011010100000\0-----------------", STATUS_SUCCESS},
1508     { 2,      1000000, 20, 33, "11110100001001000000\0--------------", STATUS_SUCCESS},
1509     { 2,     10000000, 24, 33, "100110001001011010000000\0----------", STATUS_SUCCESS},
1510     { 2,    100000000, 27, 33, "101111101011110000100000000\0-------", STATUS_SUCCESS},
1511     { 2,   1000000000, 30, 33, "111011100110101100101000000000\0----", STATUS_SUCCESS},
1512     { 2,   1073741823, 30, 33, "111111111111111111111111111111\0----", STATUS_SUCCESS},
1513     { 2,   2147483646, 31, 33, "1111111111111111111111111111110\0---", STATUS_SUCCESS},
1514     { 2,   2147483647, 31, 33, "1111111111111111111111111111111\0---", STATUS_SUCCESS}, /* max signed int */
1515     { 2,  2147483648U, 32, 33, "10000000000000000000000000000000\0--", STATUS_SUCCESS}, /* uint = -max int */
1516     { 2,  2147483649U, 32, 33, "10000000000000000000000000000001\0--", STATUS_SUCCESS},
1517     { 2,  4294967294U, 32, 33, "11111111111111111111111111111110\0--", STATUS_SUCCESS},
1518     { 2,  4294967295U, 32, 33, "11111111111111111111111111111111\0--", STATUS_SUCCESS}, /* max unsigned int */
1519
1520     { 8,  0x80000000U, 11, 12, "20000000000\0-----------------------", STATUS_SUCCESS}, /* min signed int */
1521     { 8,  -2147483647, 11, 12, "20000000001\0-----------------------", STATUS_SUCCESS},
1522     { 8,           -2, 11, 12, "37777777776\0-----------------------", STATUS_SUCCESS},
1523     { 8,           -1, 11, 12, "37777777777\0-----------------------", STATUS_SUCCESS},
1524     { 8,            0,  1, 12, "0\0---------------------------------", STATUS_SUCCESS},
1525     { 8,            1,  1, 12, "1\0---------------------------------", STATUS_SUCCESS},
1526     { 8,   2147483646, 11, 12, "17777777776\0-----------------------", STATUS_SUCCESS},
1527     { 8,   2147483647, 11, 12, "17777777777\0-----------------------", STATUS_SUCCESS}, /* max signed int */
1528     { 8,  2147483648U, 11, 12, "20000000000\0-----------------------", STATUS_SUCCESS}, /* uint = -max int */
1529     { 8,  2147483649U, 11, 12, "20000000001\0-----------------------", STATUS_SUCCESS},
1530     { 8,  4294967294U, 11, 12, "37777777776\0-----------------------", STATUS_SUCCESS},
1531     { 8,  4294967295U, 11, 12, "37777777777\0-----------------------", STATUS_SUCCESS}, /* max unsigned int */
1532
1533     {10,  0x80000000U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* min signed int */
1534     {10,  -2147483647, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS},
1535     {10,           -2, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS},
1536     {10,           -1, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS},
1537     {10,            0,  1, 11, "0\0---------------------------------", STATUS_SUCCESS},
1538     {10,            1,  1, 11, "1\0---------------------------------", STATUS_SUCCESS},
1539     {10,   2147483646, 10, 11, "2147483646\0------------------------", STATUS_SUCCESS},
1540     {10,   2147483647, 10, 11, "2147483647\0------------------------", STATUS_SUCCESS}, /* max signed int */
1541     {10,  2147483648U, 10, 11, "2147483648\0------------------------", STATUS_SUCCESS}, /* uint = -max int */
1542     {10,  2147483649U, 10, 11, "2147483649\0------------------------", STATUS_SUCCESS},
1543     {10,  4294967294U, 10, 11, "4294967294\0------------------------", STATUS_SUCCESS},
1544     {10,  4294967295U, 10, 11, "4294967295\0------------------------", STATUS_SUCCESS}, /* max unsigned int */
1545
1546     {16,  0x80000000U,  8,  9, "80000000\0--------------------------", STATUS_SUCCESS}, /* min signed int */
1547     {16,  -2147483647,  8,  9, "80000001\0--------------------------", STATUS_SUCCESS},
1548     {16,           -2,  8,  9, "FFFFFFFE\0--------------------------", STATUS_SUCCESS},
1549     {16,           -1,  8,  9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS},
1550     {16,            0,  1,  9, "0\0---------------------------------", STATUS_SUCCESS},
1551     {16,            1,  1,  9, "1\0---------------------------------", STATUS_SUCCESS},
1552     {16,   2147483646,  8,  9, "7FFFFFFE\0--------------------------", STATUS_SUCCESS},
1553     {16,   2147483647,  8,  9, "7FFFFFFF\0--------------------------", STATUS_SUCCESS}, /* max signed int */
1554     {16,  2147483648U,  8,  9, "80000000\0--------------------------", STATUS_SUCCESS}, /* uint = -max int */
1555     {16,  2147483649U,  8,  9, "80000001\0--------------------------", STATUS_SUCCESS},
1556     {16,  4294967294U,  8,  9, "FFFFFFFE\0--------------------------", STATUS_SUCCESS},
1557     {16,  4294967295U,  8,  9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS}, /* max unsigned int */
1558
1559 /*  { 2,        32768, 16, 17, "1000000000000000\0------------------", STATUS_SUCCESS}, broken on windows */
1560 /*  { 2,        32768, 16, 16, "1000000000000000-------------------",  STATUS_SUCCESS}, broken on windows */
1561     { 2,        65536, 17, 18, "10000000000000000\0-----------------", STATUS_SUCCESS},
1562     { 2,        65536, 17, 17, "10000000000000000------------------",  STATUS_SUCCESS},
1563     { 2,       131072, 18, 19, "100000000000000000\0----------------", STATUS_SUCCESS},
1564     { 2,       131072, 18, 18, "100000000000000000-----------------",  STATUS_SUCCESS},
1565     {16,   0xffffffff,  8,  9, "FFFFFFFF\0--------------------------", STATUS_SUCCESS},
1566     {16,   0xffffffff,  8,  8, "FFFFFFFF---------------------------",  STATUS_SUCCESS}, /* No \0 term */
1567     {16,   0xffffffff,  8,  7, "-----------------------------------",  STATUS_BUFFER_OVERFLOW}, /* Too short */
1568     {16,          0xa,  1,  2, "A\0---------------------------------", STATUS_SUCCESS},
1569     {16,          0xa,  1,  1, "A----------------------------------",  STATUS_SUCCESS}, /* No \0 term */
1570     {16,            0,  1,  0, "-----------------------------------",  STATUS_BUFFER_OVERFLOW},
1571     {20,   0xdeadbeef,  0,  9, "-----------------------------------",  STATUS_INVALID_PARAMETER}, /* ill. base */
1572     {-8,     07654321,  0, 12, "-----------------------------------",  STATUS_INVALID_PARAMETER}, /* neg. base */
1573 };
1574 #define NB_INT2STR (sizeof(int2str)/sizeof(*int2str))
1575
1576
1577 static void one_RtlIntegerToUnicodeString_test(int test_num, const int2str_t *int2str)
1578 {
1579     int pos;
1580     WCHAR expected_str_Buffer[STRI_BUFFER_LENGTH + 1];
1581     UNICODE_STRING expected_unicode_string;
1582     STRING expected_ansi_str;
1583     WCHAR str_Buffer[STRI_BUFFER_LENGTH + 1];
1584     UNICODE_STRING unicode_string;
1585     STRING ansi_str;
1586     NTSTATUS result;
1587
1588     for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
1589         expected_str_Buffer[pos] = int2str->Buffer[pos];
1590     }
1591     expected_unicode_string.Length = int2str->Length * sizeof(WCHAR);
1592     expected_unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR);
1593     expected_unicode_string.Buffer = expected_str_Buffer;
1594     pRtlUnicodeStringToAnsiString(&expected_ansi_str, &expected_unicode_string, 1);
1595
1596     for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
1597         str_Buffer[pos] = '-';
1598     }
1599     unicode_string.Length = 0;
1600     unicode_string.MaximumLength = int2str->MaximumLength * sizeof(WCHAR);
1601     unicode_string.Buffer = str_Buffer;
1602
1603     result = pRtlIntegerToUnicodeString(int2str->value, int2str->base, &unicode_string);
1604     pRtlUnicodeStringToAnsiString(&ansi_str, &unicode_string, 1);
1605     if (result == STATUS_BUFFER_OVERFLOW) {
1606         /* On BUFFER_OVERFLOW the string Buffer should be unchanged */
1607         for (pos = 0; pos < STRI_BUFFER_LENGTH; pos++) {
1608             expected_str_Buffer[pos] = '-';
1609         }
1610         /* w2k: The native function has two reasons for BUFFER_OVERFLOW: */
1611         /* If the value is too large to convert: The Length is unchanged */
1612         /* If str is too small to hold the string: Set str->Length to the length */
1613         /* the string would have (which can be larger than the MaximumLength). */
1614         /* To allow all this in the tests we do the following: */
1615         if (expected_unicode_string.Length > 32 && unicode_string.Length == 0) {
1616             /* The value is too large to convert only triggered when testing native */
1617             expected_unicode_string.Length = 0;
1618         }
1619     } else {
1620         ok(result == int2str->result,
1621            "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) has result %x, expected: %x\n",
1622            test_num, int2str->value, int2str->base, result, int2str->result);
1623         if (result == STATUS_SUCCESS) {
1624             ok(unicode_string.Buffer[unicode_string.Length/sizeof(WCHAR)] == '\0',
1625                "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) string \"%s\" is not NULL terminated\n",
1626                test_num, int2str->value, int2str->base, ansi_str.Buffer);
1627         }
1628     }
1629     ok(memcmp(unicode_string.Buffer, expected_unicode_string.Buffer, STRI_BUFFER_LENGTH * sizeof(WCHAR)) == 0,
1630        "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
1631        test_num, int2str->value, int2str->base, ansi_str.Buffer, expected_ansi_str.Buffer);
1632     ok(unicode_string.Length == expected_unicode_string.Length,
1633        "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) string has Length %d, expected: %d\n",
1634        test_num, int2str->value, int2str->base, unicode_string.Length, expected_unicode_string.Length);
1635     ok(unicode_string.MaximumLength == expected_unicode_string.MaximumLength,
1636        "(test %d): RtlIntegerToUnicodeString(%u, %d, [out]) string has MaximumLength %d, expected: %d\n",
1637        test_num, int2str->value, int2str->base, unicode_string.MaximumLength, expected_unicode_string.MaximumLength);
1638     pRtlFreeAnsiString(&expected_ansi_str);
1639     pRtlFreeAnsiString(&ansi_str);
1640 }
1641
1642
1643 static void test_RtlIntegerToUnicodeString(void)
1644 {
1645     size_t test_num;
1646
1647     for (test_num = 0; test_num < NB_INT2STR; test_num++)
1648         one_RtlIntegerToUnicodeString_test(test_num, &int2str[test_num]);
1649 }
1650
1651
1652 static void one_RtlIntegerToChar_test(int test_num, const int2str_t *int2str)
1653 {
1654     NTSTATUS result;
1655     char dest_str[STRI_BUFFER_LENGTH + 1];
1656
1657     memset(dest_str, '-', STRI_BUFFER_LENGTH);
1658     dest_str[STRI_BUFFER_LENGTH] = '\0';
1659     result = pRtlIntegerToChar(int2str->value, int2str->base, int2str->MaximumLength, dest_str);
1660     ok(result == int2str->result,
1661        "(test %d): RtlIntegerToChar(%u, %d, %d, [out]) has result %x, expected: %x\n",
1662        test_num, int2str->value, int2str->base, int2str->MaximumLength, result, int2str->result);
1663     ok(memcmp(dest_str, int2str->Buffer, STRI_BUFFER_LENGTH) == 0,
1664        "(test %d): RtlIntegerToChar(%u, %d, %d, [out]) assigns string \"%s\", expected: \"%s\"\n",
1665        test_num, int2str->value, int2str->base, int2str->MaximumLength, dest_str, int2str->Buffer);
1666 }
1667
1668
1669 static void test_RtlIntegerToChar(void)
1670 {
1671     NTSTATUS result;
1672     size_t test_num;
1673
1674     for (test_num = 0; test_num < NB_INT2STR; test_num++)
1675       one_RtlIntegerToChar_test(test_num, &int2str[test_num]);
1676
1677     result = pRtlIntegerToChar(int2str[0].value, 20, int2str[0].MaximumLength, NULL);
1678     ok(result == STATUS_INVALID_PARAMETER,
1679        "(test a): RtlIntegerToChar(%u, %d, %d, NULL) has result %x, expected: %x\n",
1680        int2str[0].value, 20, int2str[0].MaximumLength, result, STATUS_INVALID_PARAMETER);
1681
1682     result = pRtlIntegerToChar(int2str[0].value, 20, 0, NULL);
1683     ok(result == STATUS_INVALID_PARAMETER,
1684        "(test b): RtlIntegerToChar(%u, %d, %d, NULL) has result %x, expected: %x\n",
1685        int2str[0].value, 20, 0, result, STATUS_INVALID_PARAMETER);
1686
1687     result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, 0, NULL);
1688     ok(result == STATUS_BUFFER_OVERFLOW,
1689        "(test c): RtlIntegerToChar(%u, %d, %d, NULL) has result %x, expected: %x\n",
1690        int2str[0].value, int2str[0].base, 0, result, STATUS_BUFFER_OVERFLOW);
1691
1692     result = pRtlIntegerToChar(int2str[0].value, int2str[0].base, int2str[0].MaximumLength, NULL);
1693     ok(result == STATUS_ACCESS_VIOLATION,
1694        "(test d): RtlIntegerToChar(%u, %d, %d, NULL) has result %x, expected: %x\n",
1695        int2str[0].value, int2str[0].base, int2str[0].MaximumLength, result, STATUS_ACCESS_VIOLATION);
1696 }
1697
1698 static void test_RtlIsTextUnicode(void)
1699 {
1700     char ascii[] = "A simple string";
1701     char false_positive[] = {0x41, 0x0a, 0x0d, 0x1d};
1702     WCHAR false_negative = 0x0d0a;
1703     WCHAR unicode[] = {'A',' ','U','n','i','c','o','d','e',' ','s','t','r','i','n','g',0};
1704     WCHAR unicode_no_controls[] = {'A','U','n','i','c','o','d','e','s','t','r','i','n','g',0};
1705     /* String with both byte-reversed and standard Unicode control characters. */
1706     WCHAR mixed_controls[] = {'\t',0x9000,0x0d00,'\n',0};
1707     WCHAR *be_unicode;
1708     WCHAR *be_unicode_no_controls;
1709     BOOLEAN res;
1710     int flags;
1711     int i;
1712
1713     ok(!pRtlIsTextUnicode(ascii, sizeof(ascii), NULL), "ASCII text detected as Unicode\n");
1714
1715     res = pRtlIsTextUnicode(unicode, sizeof(unicode), NULL);
1716     ok(res ||
1717        broken(res == FALSE), /* NT4 */
1718        "Text should be Unicode\n");
1719
1720     ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, NULL), "Text should be Unicode\n");
1721
1722     flags =  IS_TEXT_UNICODE_UNICODE_MASK;
1723     ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass a Unicode\n");
1724     ok(flags == (IS_TEXT_UNICODE_STATISTICS | IS_TEXT_UNICODE_CONTROLS),
1725        "Expected flags 0x6, obtained %x\n", flags);
1726
1727     flags =  IS_TEXT_UNICODE_REVERSE_MASK;
1728     ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Text should not pass reverse Unicode tests\n");
1729     ok(flags == 0, "Expected flags 0, obtained %x\n", flags);
1730
1731     flags = IS_TEXT_UNICODE_ODD_LENGTH;
1732     ok(!pRtlIsTextUnicode(unicode, sizeof(unicode) - 1, &flags), "Odd length test should have passed\n");
1733     ok(flags == IS_TEXT_UNICODE_ODD_LENGTH, "Expected flags 0x200, obtained %x\n", flags);
1734
1735     be_unicode = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR));
1736     be_unicode[0] = 0xfffe;
1737     for (i = 0; i < sizeof(unicode)/sizeof(unicode[0]); i++)
1738     {
1739         be_unicode[i + 1] = (unicode[i] >> 8) | ((unicode[i] & 0xff) << 8);
1740     }
1741     ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, NULL), "Reverse endian should not be Unicode\n");
1742     ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), NULL), "Reverse endian should not be Unicode\n");
1743
1744     flags = IS_TEXT_UNICODE_REVERSE_MASK;
1745     ok(!pRtlIsTextUnicode(&be_unicode[1], sizeof(unicode), &flags), "Reverse endian should be Unicode\n");
1746     todo_wine
1747     ok(flags == (IS_TEXT_UNICODE_REVERSE_ASCII16 | IS_TEXT_UNICODE_REVERSE_STATISTICS | IS_TEXT_UNICODE_REVERSE_CONTROLS),
1748        "Expected flags 0x70, obtained %x\n", flags);
1749
1750     flags = IS_TEXT_UNICODE_REVERSE_MASK;
1751     ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags), "Reverse endian should be Unicode\n");
1752     ok(flags == (IS_TEXT_UNICODE_REVERSE_CONTROLS | IS_TEXT_UNICODE_REVERSE_SIGNATURE),
1753        "Expected flags 0xc0, obtained %x\n", flags);
1754
1755     /* build byte reversed unicode string with no control chars */
1756     be_unicode_no_controls = HeapAlloc(GetProcessHeap(), 0, sizeof(unicode) + sizeof(WCHAR));
1757     ok(be_unicode_no_controls != NULL, "Expected HeapAlloc to succeed.\n");
1758     be_unicode_no_controls[0] = 0xfffe;
1759     for (i = 0; i < sizeof(unicode_no_controls)/sizeof(unicode_no_controls[0]); i++)
1760         be_unicode_no_controls[i + 1] = (unicode_no_controls[i] >> 8) | ((unicode_no_controls[i] & 0xff) << 8);
1761
1762
1763     /* The following tests verify that the tests for */
1764     /* IS_TEXT_UNICODE_CONTROLS and IS_TEXT_UNICODE_REVERSE_CONTROLS */
1765     /* are not mutually exclusive. Regardless of whether the strings */
1766     /* contain an indication of endianness, the tests are still */
1767     /* run if the flag is passed to (Rtl)IsTextUnicode. */
1768
1769     /* Test IS_TEXT_UNICODE_CONTROLS flag */
1770     flags = IS_TEXT_UNICODE_CONTROLS;
1771     ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
1772     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1773
1774     flags = IS_TEXT_UNICODE_CONTROLS;
1775     ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on byte-reversed Unicode string lacking control characters.\n");
1776     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1777
1778     flags = IS_TEXT_UNICODE_CONTROLS;
1779     ok(pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should pass on Unicode string lacking control characters.\n");
1780     ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
1781
1782     flags = IS_TEXT_UNICODE_CONTROLS;
1783     ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls) + 2, &flags),
1784             "Test should not pass with standard Unicode string.\n");
1785     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1786
1787     flags = IS_TEXT_UNICODE_CONTROLS;
1788     ok(pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing control characters.\n");
1789     ok(flags == IS_TEXT_UNICODE_CONTROLS, "Expected flags 0x04, obtained %x\n", flags);
1790
1791     /* Test IS_TEXT_UNICODE_REVERSE_CONTROLS flag */
1792     flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
1793     ok(!pRtlIsTextUnicode(be_unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
1794     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1795
1796     flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
1797     ok(!pRtlIsTextUnicode(unicode_no_controls, sizeof(unicode_no_controls), &flags), "Test should not pass on Unicode string lacking control characters.\n");
1798     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1799
1800     flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
1801     ok(!pRtlIsTextUnicode(unicode, sizeof(unicode), &flags), "Test should not pass on Unicode string lacking control characters.\n");
1802     ok(flags == 0, "Expected flags 0x0, obtained %x\n", flags);
1803
1804     flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
1805     ok(!pRtlIsTextUnicode(be_unicode, sizeof(unicode) + 2, &flags),
1806         "Test should pass with byte-reversed Unicode string containing control characters.\n");
1807     ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
1808
1809     flags = IS_TEXT_UNICODE_REVERSE_CONTROLS;
1810     ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on a string containing byte-reversed control characters.\n");
1811     ok(flags == IS_TEXT_UNICODE_REVERSE_CONTROLS, "Expected flags 0x40, obtained %x\n", flags);
1812
1813     /* Test with flags for both byte-reverse and standard Unicode characters */
1814     flags = IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS;
1815     ok(!pRtlIsTextUnicode(mixed_controls, sizeof(mixed_controls), &flags), "Test should pass on string containing both byte-reversed and standard control characters.\n");
1816     ok(flags == (IS_TEXT_UNICODE_CONTROLS | IS_TEXT_UNICODE_REVERSE_CONTROLS), "Expected flags 0x44, obtained %x\n", flags);
1817
1818     flags = IS_TEXT_UNICODE_STATISTICS;
1819     todo_wine ok(pRtlIsTextUnicode(false_positive, sizeof(false_positive), &flags), "Test should pass on false positive.\n");
1820
1821     ok(!pRtlIsTextUnicode(&false_negative, sizeof(false_negative), NULL), "Test should fail on 0x0d0a (MALAYALAM LETTER UU).\n");
1822
1823     HeapFree(GetProcessHeap(), 0, be_unicode);
1824     HeapFree(GetProcessHeap(), 0, be_unicode_no_controls);
1825 }
1826
1827 static const WCHAR szGuid[] = { '{','0','1','0','2','0','3','0','4','-',
1828   '0','5','0','6','-'  ,'0','7','0','8','-','0','9','0','A','-',
1829   '0','B','0','C','0','D','0','E','0','F','0','A','}','\0' };
1830 static const WCHAR szGuid2[] = { '{','0','1','0','2','0','3','0','4','-',
1831   '0','5','0','6','-'  ,'0','7','0','8','-','0','9','0','A','-',
1832   '0','B','0','C','0','D','0','E','0','F','0','A',']','\0' };
1833 DEFINE_GUID(IID_Endianness, 0x01020304, 0x0506, 0x0708, 0x09, 0x0A, 0x0B,
1834             0x0C, 0x0D, 0x0E, 0x0F, 0x0A);
1835
1836 static void test_RtlGUIDFromString(void)
1837 {
1838   GUID guid;
1839   UNICODE_STRING str;
1840   NTSTATUS ret;
1841
1842   str.Length = str.MaximumLength = sizeof(szGuid) - sizeof(WCHAR);
1843   str.Buffer = (LPWSTR)szGuid;
1844
1845   ret = pRtlGUIDFromString(&str, &guid);
1846   ok(ret == 0, "expected ret=0, got 0x%0x\n", ret);
1847   ok(IsEqualGUID(&guid, &IID_Endianness), "Endianness broken\n");
1848
1849   str.Length = str.MaximumLength = sizeof(szGuid2) - sizeof(WCHAR);
1850   str.Buffer = (LPWSTR)szGuid2;
1851
1852   ret = pRtlGUIDFromString(&str, &guid);
1853   ok(ret, "expected ret!=0\n");
1854 }
1855
1856 static void test_RtlStringFromGUID(void)
1857 {
1858   UNICODE_STRING str;
1859   NTSTATUS ret;
1860
1861   str.Length = str.MaximumLength = 0;
1862   str.Buffer = NULL;
1863
1864   ret = pRtlStringFromGUID(&IID_Endianness, &str);
1865   ok(ret == 0, "expected ret=0, got 0x%0x\n", ret);
1866   ok(str.Buffer && !lstrcmpiW(str.Buffer, szGuid), "Endianness broken\n");
1867   pRtlFreeUnicodeString(&str);
1868 }
1869
1870 START_TEST(rtlstr)
1871 {
1872     InitFunctionPtrs();
1873     if (pRtlInitAnsiString) {
1874         test_RtlInitString();
1875         test_RtlInitUnicodeString();
1876         test_RtlCopyString();
1877         test_RtlUnicodeStringToInteger();
1878         test_RtlCharToInteger();
1879         test_RtlIntegerToUnicodeString();
1880         test_RtlIntegerToChar();
1881         test_RtlUpperChar();
1882         test_RtlUpperString();
1883         test_RtlUnicodeStringToAnsiString();
1884         test_RtlAppendAsciizToString();
1885         test_RtlAppendStringToString();
1886         test_RtlAppendUnicodeToString();
1887         test_RtlAppendUnicodeStringToString();
1888     }
1889
1890     if (pRtlInitUnicodeStringEx)
1891         test_RtlInitUnicodeStringEx();
1892     if (pRtlDuplicateUnicodeString)
1893         test_RtlDuplicateUnicodeString();
1894     if (pRtlFindCharInUnicodeString)
1895         test_RtlFindCharInUnicodeString();
1896     if (pRtlGUIDFromString)
1897         test_RtlGUIDFromString();
1898     if (pRtlStringFromGUID)
1899         test_RtlStringFromGUID();
1900     if (pRtlIsTextUnicode)
1901         test_RtlIsTextUnicode();
1902     if(0)
1903     {
1904         test_RtlUpcaseUnicodeChar();
1905         test_RtlUpcaseUnicodeString();
1906         test_RtlDowncaseUnicodeString();
1907     }
1908 }