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

   1 /* Unit test suite for Ntdll file functions
   2  *
   3  * Copyright 2007 Jeff Latimer
   4  * Copyright 2007 Andrey Turkin
   5  * Copyright 2008 Jeff Zaroyko
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES
  22  * We use function pointers here as there is no import library for NTDLL on
  23  * windows.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdarg.h>
  28
  29 #include "ntstatus.h"
  30 /* Define WIN32_NO_STATUS so MSVC does not give us duplicate macro
  31  * definition errors when we get to winnt.h
  32  */
  33 #define WIN32_NO_STATUS
  34
  35 #include "wine/test.h"
  36 #include "winternl.h"
  37 #include "winuser.h"
  38
  39 #ifndef IO_COMPLETION_ALL_ACCESS
  40 #define IO_COMPLETION_ALL_ACCESS 0x001F0003
  41 #endif
  42
  43 static BOOL     (WINAPI * pGetVolumePathNameW)(LPCWSTR, LPWSTR, DWORD);
  44 static UINT     (WINAPI *pGetSystemWow64DirectoryW)( LPWSTR, UINT );
  45
  46 static NTSTATUS (WINAPI *pRtlFreeUnicodeString)( PUNICODE_STRING );
  47 static VOID     (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
  48 static BOOL     (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* );
  49 static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirectionEx)( ULONG, ULONG * );
  50
  51 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
  52                                        ULONG, ULONG, ULONG, PLARGE_INTEGER );
  53 static NTSTATUS (WINAPI *pNtOpenFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
  54 static NTSTATUS (WINAPI *pNtDeleteFile)(POBJECT_ATTRIBUTES ObjectAttributes);
  55 static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
  56                                       PIO_APC_ROUTINE apc, void* apc_user,
  57                                       PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
  58                                       PLARGE_INTEGER offset, PULONG key);
  59 static NTSTATUS (WINAPI *pNtWriteFile)(HANDLE hFile, HANDLE hEvent,
  60                                        PIO_APC_ROUTINE apc, void* apc_user,
  61                                        PIO_STATUS_BLOCK io_status,
  62                                        const void* buffer, ULONG length,
  63                                        PLARGE_INTEGER offset, PULONG key);
  64 static NTSTATUS (WINAPI *pNtCancelIoFile)(HANDLE hFile, PIO_STATUS_BLOCK io_status);
  65 static NTSTATUS (WINAPI *pNtCancelIoFileEx)(HANDLE hFile, PIO_STATUS_BLOCK iosb, PIO_STATUS_BLOCK io_status);
  66 static NTSTATUS (WINAPI *pNtClose)( PHANDLE );
  67
  68 static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
  69 static NTSTATUS (WINAPI *pNtOpenIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
  70 static NTSTATUS (WINAPI *pNtQueryIoCompletion)(HANDLE, IO_COMPLETION_INFORMATION_CLASS, PVOID, ULONG, PULONG);
  71 static NTSTATUS (WINAPI *pNtRemoveIoCompletion)(HANDLE, PULONG_PTR, PULONG_PTR, PIO_STATUS_BLOCK, PLARGE_INTEGER);
  72 static NTSTATUS (WINAPI *pNtSetIoCompletion)(HANDLE, ULONG_PTR, ULONG_PTR, NTSTATUS, ULONG);
  73 static NTSTATUS (WINAPI *pNtSetInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
  74 static NTSTATUS (WINAPI *pNtQueryInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
  75 static NTSTATUS (WINAPI *pNtQueryDirectoryFile)(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,
  76                                                 PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
  77
  78 static inline BOOL is_signaled( HANDLE obj )
  79 {
  80     return WaitForSingleObject( obj, 0 ) == 0;
  81 }
  82
  83 #define PIPENAME "\\\\.\\pipe\\ntdll_tests_file.c"
  84 #define TEST_BUF_LEN 3
  85
  86 static BOOL create_pipe( HANDLE *read, HANDLE *write, ULONG flags, ULONG size )
  87 {
  88     *read = CreateNamedPipe(PIPENAME, PIPE_ACCESS_INBOUND | flags, PIPE_TYPE_BYTE | PIPE_WAIT,
  89                             1, size, size, NMPWAIT_USE_DEFAULT_WAIT, NULL);
  90     ok(*read != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
  91
  92     *write = CreateFileA(PIPENAME, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
  93     ok(*write != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError());
  94
  95     return TRUE;
  96 }
  97
  98 static HANDLE create_temp_file( ULONG flags )
  99 {
 100     char buffer[MAX_PATH];
 101     HANDLE handle;
 102
 103     GetTempFileNameA( ".", "foo", 0, buffer );
 104     handle = CreateFileA(buffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 105                          flags | FILE_FLAG_DELETE_ON_CLOSE, 0);
 106     ok( handle != INVALID_HANDLE_VALUE, "failed to create temp file\n" );
 107     return (handle == INVALID_HANDLE_VALUE) ? 0 : handle;
 108 }
 109
 110 #define CVALUE_FIRST 0xfffabbcc
 111 #define CKEY_FIRST 0x1030341
 112 #define CKEY_SECOND 0x132E46
 113
 114 ULONG_PTR completionKey;
 115 IO_STATUS_BLOCK ioSb;
 116 ULONG_PTR completionValue;
 117
 118 static long get_pending_msgs(HANDLE h)
 119 {
 120     NTSTATUS res;
 121     ULONG a, req;
 122
 123     res = pNtQueryIoCompletion( h, IoCompletionBasicInformation, &a, sizeof(a), &req );
 124     ok( res == STATUS_SUCCESS, "NtQueryIoCompletion failed: %x\n", res );
 125     if (res != STATUS_SUCCESS) return -1;
 126     ok( req == sizeof(a), "Unexpected response size: %x\n", req );
 127     return a;
 128 }
 129
 130 static BOOL get_msg(HANDLE h)
 131 {
 132     LARGE_INTEGER timeout = {{-10000000*3}};
 133     DWORD res = pNtRemoveIoCompletion( h, &completionKey, &completionValue, &ioSb, &timeout);
 134     ok( res == STATUS_SUCCESS, "NtRemoveIoCompletion failed: %x\n", res );
 135     if (res != STATUS_SUCCESS)
 136     {
 137         completionKey = completionValue = 0;
 138         memset(&ioSb, 0, sizeof(ioSb));
 139         return FALSE;
 140     }
 141     return TRUE;
 142 }
 143
 144
 145 static void WINAPI apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
 146 {
 147     int *count = arg;
 148
 149     trace( "apc called block %p iosb.status %x iosb.info %lu\n",
 150            iosb, U(*iosb).Status, iosb->Information );
 151     (*count)++;
 152     ok( !reserved, "reserved is not 0: %x\n", reserved );
 153 }
 154
 155 static void open_file_test(void)
 156 {
 157     NTSTATUS status;
 158     HANDLE dir, handle;
 159     WCHAR path[MAX_PATH];
 160     BYTE data[8192];
 161     OBJECT_ATTRIBUTES attr;
 162     IO_STATUS_BLOCK io;
 163     UNICODE_STRING nameW;
 164     UINT i, len;
 165     BOOL restart = TRUE;
 166
 167     len = GetWindowsDirectoryW( path, MAX_PATH );
 168     pRtlDosPathNameToNtPathName_U( path, &nameW, NULL, NULL );
 169     attr.Length = sizeof(attr);
 170     attr.RootDirectory = 0;
 171     attr.ObjectName = &nameW;
 172     attr.Attributes = OBJ_CASE_INSENSITIVE;
 173     attr.SecurityDescriptor = NULL;
 174     attr.SecurityQualityOfService = NULL;
 175     status = pNtOpenFile( &dir, GENERIC_READ, &attr, &io,
 176                           FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
 177     ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
 178
 179     /* test opening system dir with RootDirectory set to windows dir */
 180     GetSystemDirectoryW( path, MAX_PATH );
 181     while (path[len] == '\\') len++;
 182     nameW.Buffer = path + len;
 183     nameW.Length = lstrlenW(path + len) * sizeof(WCHAR);
 184     attr.RootDirectory = dir;
 185     status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
 186                           FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
 187     ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
 188     CloseHandle( handle );
 189
 190     /* try uppercase name */
 191     for (i = len; path[i]; i++) if (path[i] >= 'a' && path[i] <= 'z') path[i] -= 'a' - 'A';
 192     status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
 193                           FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
 194     ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
 195     CloseHandle( handle );
 196
 197     /* try with leading backslash */
 198     nameW.Buffer--;
 199     nameW.Length += sizeof(WCHAR);
 200     status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
 201                           FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
 202     ok( status == STATUS_INVALID_PARAMETER ||
 203         status == STATUS_OBJECT_NAME_INVALID ||
 204         status == STATUS_OBJECT_PATH_SYNTAX_BAD,
 205         "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
 206     if (!status) CloseHandle( handle );
 207
 208     /* try with empty name */
 209     nameW.Length = 0;
 210     status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
 211                           FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
 212     ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
 213     CloseHandle( handle );
 214
 215     /* try open by file id */
 216
 217     while (!pNtQueryDirectoryFile( dir, NULL, NULL, NULL, &io, data, sizeof(data),
 218                                    FileIdBothDirectoryInformation, FALSE, NULL, restart ))
 219     {
 220         FILE_ID_BOTH_DIRECTORY_INFORMATION *info = (FILE_ID_BOTH_DIRECTORY_INFORMATION *)data;
 221
 222         restart = FALSE;
 223         for (;;)
 224         {
 225             if (!info->FileId.QuadPart) goto next;
 226             nameW.Buffer = (WCHAR *)&info->FileId;
 227             nameW.Length = sizeof(info->FileId);
 228             info->FileName[info->FileNameLength/sizeof(WCHAR)] = 0;
 229             status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
 230                                   FILE_SHARE_READ|FILE_SHARE_WRITE,
 231                                   FILE_OPEN_BY_FILE_ID |
 232                                   ((info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? FILE_DIRECTORY_FILE : 0) );
 233             ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED || status == STATUS_NOT_IMPLEMENTED,
 234                 "open %s failed %x\n", wine_dbgstr_w(info->FileName), status );
 235             if (status == STATUS_NOT_IMPLEMENTED)
 236             {
 237                 win_skip( "FILE_OPEN_BY_FILE_ID not supported\n" );
 238                 break;
 239             }
 240             if (!status)
 241             {
 242                 FILE_ALL_INFORMATION all_info;
 243
 244                 if (!pNtQueryInformationFile( handle, &io, &all_info, sizeof(all_info), FileAllInformation ))
 245                 {
 246                     /* check that it's the same file */
 247                     ok( info->EndOfFile.QuadPart == all_info.StandardInformation.EndOfFile.QuadPart,
 248                         "mismatched file size for %s\n", wine_dbgstr_w(info->FileName));
 249                     ok( info->LastWriteTime.QuadPart == all_info.BasicInformation.LastWriteTime.QuadPart,
 250                         "mismatched write time for %s\n", wine_dbgstr_w(info->FileName));
 251                 }
 252                 CloseHandle( handle );
 253             }
 254         next:
 255             if (!info->NextEntryOffset) break;
 256             info = (FILE_ID_BOTH_DIRECTORY_INFORMATION *)((char *)info + info->NextEntryOffset);
 257         }
 258     }
 259
 260     CloseHandle( dir );
 261 }
 262
 263 static void delete_file_test(void)
 264 {
 265     NTSTATUS ret;
 266     OBJECT_ATTRIBUTES attr;
 267     UNICODE_STRING nameW;
 268     WCHAR pathW[MAX_PATH];
 269     WCHAR pathsubW[MAX_PATH];
 270     static const WCHAR testdirW[] = {'n','t','d','e','l','e','t','e','f','i','l','e',0};
 271     static const WCHAR subdirW[]  = {'\\','s','u','b',0};
 272
 273     ret = GetTempPathW(MAX_PATH, pathW);
 274     if (!ret)
 275     {
 276         ok(0, "couldn't get temp dir\n");
 277         return;
 278     }
 279     if (ret + sizeof(testdirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
 280     {
 281         ok(0, "MAX_PATH exceeded in constructing paths\n");
 282         return;
 283     }
 284
 285     lstrcatW(pathW, testdirW);
 286     lstrcpyW(pathsubW, pathW);
 287     lstrcatW(pathsubW, subdirW);
 288
 289     ret = CreateDirectoryW(pathW, NULL);
 290     ok(ret == TRUE, "couldn't create directory ntdeletefile\n");
 291     if (!pRtlDosPathNameToNtPathName_U(pathW, &nameW, NULL, NULL))
 292     {
 293         ok(0,"RtlDosPathNametoNtPathName_U failed\n");
 294         return;
 295     }
 296
 297     attr.Length = sizeof(attr);
 298     attr.RootDirectory = 0;
 299     attr.Attributes = OBJ_CASE_INSENSITIVE;
 300     attr.ObjectName = &nameW;
 301     attr.SecurityDescriptor = NULL;
 302     attr.SecurityQualityOfService = NULL;
 303
 304     /* test NtDeleteFile on an empty directory */
 305     ret = pNtDeleteFile(&attr);
 306     ok(ret == STATUS_SUCCESS, "NtDeleteFile should succeed in removing an empty directory\n");
 307     ret = RemoveDirectoryW(pathW);
 308     ok(ret == FALSE, "expected to fail removing directory, NtDeleteFile should have removed it\n");
 309
 310     /* test NtDeleteFile on a non-empty directory */
 311     ret = CreateDirectoryW(pathW, NULL);
 312     ok(ret == TRUE, "couldn't create directory ntdeletefile ?!\n");
 313     ret = CreateDirectoryW(pathsubW, NULL);
 314     ok(ret == TRUE, "couldn't create directory subdir\n");
 315     ret = pNtDeleteFile(&attr);
 316     ok(ret == STATUS_SUCCESS, "expected NtDeleteFile to ret STATUS_SUCCESS\n");
 317     ret = RemoveDirectoryW(pathsubW);
 318     ok(ret == TRUE, "expected to remove directory ntdeletefile\\sub\n");
 319     ret = RemoveDirectoryW(pathW);
 320     ok(ret == TRUE, "expected to remove directory ntdeletefile, NtDeleteFile failed.\n");
 321
 322     pRtlFreeUnicodeString( &nameW );
 323 }
 324
 325 static void read_file_test(void)
 326 {
 327     const char text[] = "foobar";
 328     HANDLE handle, read, write;
 329     NTSTATUS status;
 330     IO_STATUS_BLOCK iosb, iosb2;
 331     DWORD written;
 332     int apc_count = 0;
 333     char buffer[128];
 334     LARGE_INTEGER offset;
 335     HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL );
 336
 337     buffer[0] = 1;
 338
 339     if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
 340
 341     /* try read with no data */
 342     U(iosb).Status = 0xdeadbabe;
 343     iosb.Information = 0xdeadbeef;
 344     ok( is_signaled( read ), "read handle is not signaled\n" );
 345     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
 346     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 347     ok( !is_signaled( read ), "read handle is signaled\n" );
 348     ok( !is_signaled( event ), "event is signaled\n" );
 349     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 350     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 351     ok( !apc_count, "apc was called\n" );
 352     WriteFile( write, buffer, 1, &written, NULL );
 353     /* iosb updated here by async i/o */
 354     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 355     ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
 356     ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
 357     ok( !is_signaled( read ), "read handle is signaled\n" );
 358     ok( is_signaled( event ), "event is not signaled\n" );
 359     ok( !apc_count, "apc was called\n" );
 360     apc_count = 0;
 361     SleepEx( 1, FALSE ); /* non-alertable sleep */
 362     ok( !apc_count, "apc was called\n" );
 363     SleepEx( 1, TRUE ); /* alertable sleep */
 364     ok( apc_count == 1, "apc not called\n" );
 365
 366     /* with no event, the pipe handle itself gets signaled */
 367     apc_count = 0;
 368     U(iosb).Status = 0xdeadbabe;
 369     iosb.Information = 0xdeadbeef;
 370     ok( !is_signaled( read ), "read handle is not signaled\n" );
 371     status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
 372     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 373     ok( !is_signaled( read ), "read handle is signaled\n" );
 374     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 375     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 376     ok( !apc_count, "apc was called\n" );
 377     WriteFile( write, buffer, 1, &written, NULL );
 378     /* iosb updated here by async i/o */
 379     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 380     ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
 381     ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
 382     ok( is_signaled( read ), "read handle is signaled\n" );
 383     ok( !apc_count, "apc was called\n" );
 384     apc_count = 0;
 385     SleepEx( 1, FALSE ); /* non-alertable sleep */
 386     ok( !apc_count, "apc was called\n" );
 387     SleepEx( 1, TRUE ); /* alertable sleep */
 388     ok( apc_count == 1, "apc not called\n" );
 389
 390     /* now read with data ready */
 391     apc_count = 0;
 392     U(iosb).Status = 0xdeadbabe;
 393     iosb.Information = 0xdeadbeef;
 394     ResetEvent( event );
 395     WriteFile( write, buffer, 1, &written, NULL );
 396     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
 397     ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
 398     ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
 399     ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
 400     ok( is_signaled( event ), "event is not signaled\n" );
 401     ok( !apc_count, "apc was called\n" );
 402     SleepEx( 1, FALSE ); /* non-alertable sleep */
 403     ok( !apc_count, "apc was called\n" );
 404     SleepEx( 1, TRUE ); /* alertable sleep */
 405     ok( apc_count == 1, "apc not called\n" );
 406
 407     /* try read with no data */
 408     apc_count = 0;
 409     U(iosb).Status = 0xdeadbabe;
 410     iosb.Information = 0xdeadbeef;
 411     ok( is_signaled( event ), "event is not signaled\n" ); /* check that read resets the event */
 412     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 413     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 414     ok( !is_signaled( event ), "event is signaled\n" );
 415     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 416     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 417     ok( !apc_count, "apc was called\n" );
 418     WriteFile( write, buffer, 1, &written, NULL );
 419     /* partial read is good enough */
 420     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 421     ok( is_signaled( event ), "event is signaled\n" );
 422     ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
 423     ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
 424     ok( !apc_count, "apc was called\n" );
 425     SleepEx( 1, TRUE ); /* alertable sleep */
 426     ok( apc_count == 1, "apc was not called\n" );
 427
 428     /* read from disconnected pipe */
 429     apc_count = 0;
 430     U(iosb).Status = 0xdeadbabe;
 431     iosb.Information = 0xdeadbeef;
 432     CloseHandle( write );
 433     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
 434     ok( status == STATUS_PIPE_BROKEN, "wrong status %x\n", status );
 435     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 436     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 437     ok( !is_signaled( event ), "event is signaled\n" );
 438     ok( !apc_count, "apc was called\n" );
 439     SleepEx( 1, TRUE ); /* alertable sleep */
 440     ok( !apc_count, "apc was called\n" );
 441     CloseHandle( read );
 442
 443     /* read from closed handle */
 444     apc_count = 0;
 445     U(iosb).Status = 0xdeadbabe;
 446     iosb.Information = 0xdeadbeef;
 447     SetEvent( event );
 448     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
 449     ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status );
 450     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 451     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 452     ok( is_signaled( event ), "event is signaled\n" );  /* not reset on invalid handle */
 453     ok( !apc_count, "apc was called\n" );
 454     SleepEx( 1, TRUE ); /* alertable sleep */
 455     ok( !apc_count, "apc was called\n" );
 456
 457     /* disconnect while async read is in progress */
 458     if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
 459     apc_count = 0;
 460     U(iosb).Status = 0xdeadbabe;
 461     iosb.Information = 0xdeadbeef;
 462     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 463     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 464     ok( !is_signaled( event ), "event is signaled\n" );
 465     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 466     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 467     ok( !apc_count, "apc was called\n" );
 468     CloseHandle( write );
 469     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 470     ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status );
 471     ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 472     ok( is_signaled( event ), "event is signaled\n" );
 473     ok( !apc_count, "apc was called\n" );
 474     SleepEx( 1, TRUE ); /* alertable sleep */
 475     ok( apc_count == 1, "apc was not called\n" );
 476     CloseHandle( read );
 477
 478     if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
 479     ok(DuplicateHandle(GetCurrentProcess(), read, GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS),
 480         "Failed to duplicate handle: %d\n", GetLastError());
 481
 482     apc_count = 0;
 483     U(iosb).Status = 0xdeadbabe;
 484     iosb.Information = 0xdeadbeef;
 485     status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 486     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 487     ok( !is_signaled( event ), "event is signaled\n" );
 488     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 489     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 490     ok( !apc_count, "apc was called\n" );
 491     /* Cancel by other handle */
 492     status = pNtCancelIoFile( read, &iosb2 );
 493     ok(status == STATUS_SUCCESS, "failed to cancel by different handle: %x\n", status);
 494     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 495     ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
 496     ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 497     ok( is_signaled( event ), "event is signaled\n" );
 498     todo_wine ok( !apc_count, "apc was called\n" );
 499     SleepEx( 1, TRUE ); /* alertable sleep */
 500     ok( apc_count == 1, "apc was not called\n" );
 501
 502     apc_count = 0;
 503     U(iosb).Status = 0xdeadbabe;
 504     iosb.Information = 0xdeadbeef;
 505     status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 506     ok( status == STATUS_PENDING, "wrong status %x\n", status );
 507     ok( !is_signaled( event ), "event is signaled\n" );
 508     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 509     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 510     ok( !apc_count, "apc was called\n" );
 511     /* Close queued handle */
 512     CloseHandle( read );
 513     SleepEx( 1, TRUE ); /* alertable sleep */
 514     ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 515     ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 516     status = pNtCancelIoFile( read, &iosb2 );
 517     ok(status == STATUS_INVALID_HANDLE, "cancelled by closed handle?\n");
 518     status = pNtCancelIoFile( handle, &iosb2 );
 519     ok(status == STATUS_SUCCESS, "failed to cancel: %x\n", status);
 520     Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 521     ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
 522     ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 523     ok( is_signaled( event ), "event is signaled\n" );
 524     todo_wine ok( !apc_count, "apc was called\n" );
 525     SleepEx( 1, TRUE ); /* alertable sleep */
 526     ok( apc_count == 1, "apc was not called\n" );
 527     CloseHandle( handle );
 528     CloseHandle( write );
 529
 530     if (pNtCancelIoFileEx)
 531     {
 532         /* Basic Cancel Ex */
 533         if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
 534
 535         apc_count = 0;
 536         U(iosb).Status = 0xdeadbabe;
 537         iosb.Information = 0xdeadbeef;
 538         status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 539         ok( status == STATUS_PENDING, "wrong status %x\n", status );
 540         ok( !is_signaled( event ), "event is signaled\n" );
 541         ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 542         ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 543         ok( !apc_count, "apc was called\n" );
 544         status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
 545         ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
 546         Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 547         ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
 548         ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 549         ok( is_signaled( event ), "event is signaled\n" );
 550         todo_wine ok( !apc_count, "apc was called\n" );
 551         SleepEx( 1, TRUE ); /* alertable sleep */
 552         ok( apc_count == 1, "apc was not called\n" );
 553
 554         /* Duplicate iosb */
 555         apc_count = 0;
 556         U(iosb).Status = 0xdeadbabe;
 557         iosb.Information = 0xdeadbeef;
 558         status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 559         ok( status == STATUS_PENDING, "wrong status %x\n", status );
 560         ok( !is_signaled( event ), "event is signaled\n" );
 561         ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 562         ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 563         ok( !apc_count, "apc was called\n" );
 564         status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
 565         ok( status == STATUS_PENDING, "wrong status %x\n", status );
 566         ok( !is_signaled( event ), "event is signaled\n" );
 567         ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 568         ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 569         ok( !apc_count, "apc was called\n" );
 570         status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
 571         ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
 572         Sleep(1);  /* FIXME: needed for wine to run the i/o apc  */
 573         ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
 574         ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 575         ok( is_signaled( event ), "event is signaled\n" );
 576         todo_wine ok( !apc_count, "apc was called\n" );
 577         SleepEx( 1, TRUE ); /* alertable sleep */
 578         ok( apc_count == 2, "apc was not called\n" );
 579
 580         CloseHandle( read );
 581         CloseHandle( write );
 582     }
 583
 584     /* now try a real file */
 585     if (!(handle = create_temp_file( FILE_FLAG_OVERLAPPED ))) return;
 586     apc_count = 0;
 587     U(iosb).Status = 0xdeadbabe;
 588     iosb.Information = 0xdeadbeef;
 589     offset.QuadPart = 0;
 590     ResetEvent( event );
 591     status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
 592     ok( status == STATUS_SUCCESS || status == STATUS_PENDING, "wrong status %x\n", status );
 593     ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
 594     ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
 595     ok( is_signaled( event ), "event is signaled\n" );
 596     ok( !apc_count, "apc was called\n" );
 597     SleepEx( 1, TRUE ); /* alertable sleep */
 598     ok( apc_count == 1, "apc was not called\n" );
 599
 600     apc_count = 0;
 601     U(iosb).Status = 0xdeadbabe;
 602     iosb.Information = 0xdeadbeef;
 603     offset.QuadPart = 0;
 604     ResetEvent( event );
 605     status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
 606     ok( status == STATUS_SUCCESS ||
 607         status == STATUS_PENDING, /* vista */
 608         "wrong status %x\n", status );
 609     ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
 610     ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
 611     ok( is_signaled( event ), "event is signaled\n" );
 612     ok( !apc_count, "apc was called\n" );
 613     SleepEx( 1, TRUE ); /* alertable sleep */
 614     ok( apc_count == 1, "apc was not called\n" );
 615
 616     /* read beyond eof */
 617     apc_count = 0;
 618     U(iosb).Status = 0xdeadbabe;
 619     iosb.Information = 0xdeadbeef;
 620     offset.QuadPart = strlen(text) + 2;
 621     status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
 622     if (status == STATUS_PENDING)  /* vista */
 623     {
 624         ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
 625         ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 626         ok( is_signaled( event ), "event is signaled\n" );
 627         ok( !apc_count, "apc was called\n" );
 628         SleepEx( 1, TRUE ); /* alertable sleep */
 629         ok( apc_count == 1, "apc was not called\n" );
 630     }
 631     else
 632     {
 633         ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
 634         ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
 635         ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
 636         ok( !is_signaled( event ), "event is signaled\n" );
 637         ok( !apc_count, "apc was called\n" );
 638         SleepEx( 1, TRUE ); /* alertable sleep */
 639         ok( !apc_count, "apc was called\n" );
 640     }
 641     CloseHandle( handle );
 642
 643     /* now a non-overlapped file */
 644     if (!(handle = create_temp_file(0))) return;
 645     apc_count = 0;
 646     U(iosb).Status = 0xdeadbabe;
 647     iosb.Information = 0xdeadbeef;
 648     offset.QuadPart = 0;
 649     status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
 650     ok( status == STATUS_END_OF_FILE ||
 651         status == STATUS_SUCCESS ||
 652         status == STATUS_PENDING,  /* vista */
 653         "wrong status %x\n", status );
 654     ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
 655     ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
 656     ok( is_signaled( event ), "event is signaled\n" );
 657     ok( !apc_count, "apc was called\n" );
 658     SleepEx( 1, TRUE ); /* alertable sleep */
 659     ok( apc_count == 1, "apc was not called\n" );
 660
 661     apc_count = 0;
 662     U(iosb).Status = 0xdeadbabe;
 663     iosb.Information = 0xdeadbeef;
 664     offset.QuadPart = 0;
 665     ResetEvent( event );
 666     status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
 667     ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
 668     ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
 669     ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
 670     ok( is_signaled( event ), "event is signaled\n" );
 671     ok( !apc_count, "apc was called\n" );
 672     SleepEx( 1, TRUE ); /* alertable sleep */
 673     todo_wine ok( !apc_count, "apc was called\n" );
 674
 675     /* read beyond eof */
 676     apc_count = 0;
 677     U(iosb).Status = 0xdeadbabe;
 678     iosb.Information = 0xdeadbeef;
 679     offset.QuadPart = strlen(text) + 2;
 680     ResetEvent( event );
 681     status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
 682     ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
 683     todo_wine ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
 684     todo_wine ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
 685     todo_wine ok( is_signaled( event ), "event is not signaled\n" );
 686     ok( !apc_count, "apc was called\n" );
 687     SleepEx( 1, TRUE ); /* alertable sleep */
 688     ok( !apc_count, "apc was called\n" );
 689
 690     CloseHandle( handle );
 691
 692     CloseHandle( event );
 693 }
 694
 695 static void nt_mailslot_test(void)
 696 {
 697     HANDLE hslot;
 698     ACCESS_MASK DesiredAccess;
 699     OBJECT_ATTRIBUTES attr;
 700
 701     ULONG CreateOptions;
 702     ULONG MailslotQuota;
 703     ULONG MaxMessageSize;
 704     LARGE_INTEGER TimeOut;
 705     IO_STATUS_BLOCK IoStatusBlock;
 706     NTSTATUS rc;
 707     UNICODE_STRING str;
 708     WCHAR buffer1[] = { '\\','?','?','\\','M','A','I','L','S','L','O','T','\\',
 709                         'R',':','\\','F','R','E','D','\0' };
 710
 711     TimeOut.QuadPart = -1;
 712
 713     pRtlInitUnicodeString(&str, buffer1);
 714     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 715     CreateOptions = MailslotQuota = MaxMessageSize = 0;
 716     DesiredAccess = GENERIC_READ;
 717
 718     /*
 719      * Check for NULL pointer handling
 720      */
 721     rc = pNtCreateMailslotFile(NULL, DesiredAccess,
 722          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 723          &TimeOut);
 724     ok( rc == STATUS_ACCESS_VIOLATION ||
 725         rc == STATUS_INVALID_PARAMETER, /* win2k3 */
 726         "rc = %x not STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER\n", rc);
 727
 728     /*
 729      * Test to see if the Timeout can be NULL
 730      */
 731     hslot = (HANDLE)0xdeadbeef;
 732     rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
 733          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 734          NULL);
 735     ok( rc == STATUS_SUCCESS ||
 736         rc == STATUS_INVALID_PARAMETER, /* win2k3 */
 737         "rc = %x not STATUS_SUCCESS or STATUS_INVALID_PARAMETER\n", rc);
 738     ok( hslot != 0, "Handle is invalid\n");
 739
 740     if  ( rc == STATUS_SUCCESS ) rc = pNtClose(hslot);
 741
 742     /*
 743      * Test that the length field is checked properly
 744      */
 745     attr.Length = 0;
 746     rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
 747          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 748          &TimeOut);
 749     todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
 750
 751     if  (rc == STATUS_SUCCESS) pNtClose(hslot);
 752
 753     attr.Length = sizeof(OBJECT_ATTRIBUTES)+1;
 754     rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
 755          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 756          &TimeOut);
 757     todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
 758
 759     if  (rc == STATUS_SUCCESS) pNtClose(hslot);
 760
 761     /*
 762      * Test handling of a NULL unicode string in ObjectName
 763      */
 764     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 765     attr.ObjectName = NULL;
 766     rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
 767          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 768          &TimeOut);
 769     ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD ||
 770         rc == STATUS_INVALID_PARAMETER,
 771         "rc = %x not STATUS_OBJECT_PATH_SYNTAX_BAD or STATUS_INVALID_PARAMETER\n", rc);
 772
 773     if  (rc == STATUS_SUCCESS) pNtClose(hslot);
 774
 775     /*
 776      * Test a valid call
 777      */
 778     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
 779     rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
 780          &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
 781          &TimeOut);
 782     ok( rc == STATUS_SUCCESS, "Create MailslotFile failed rc = %x\n", rc);
 783     ok( hslot != 0, "Handle is invalid\n");
 784
 785     rc = pNtClose(hslot);
 786     ok( rc == STATUS_SUCCESS, "NtClose failed\n");
 787 }
 788
 789 static void test_iocp_setcompletion(HANDLE h)
 790 {
 791     NTSTATUS res;
 792     long count;
 793
 794     res = pNtSetIoCompletion( h, CKEY_FIRST, CVALUE_FIRST, STATUS_INVALID_DEVICE_REQUEST, 3 );
 795     ok( res == STATUS_SUCCESS, "NtSetIoCompletion failed: %x\n", res );
 796
 797     count = get_pending_msgs(h);
 798     ok( count == 1, "Unexpected msg count: %ld\n", count );
 799
 800     if (get_msg(h))
 801     {
 802         ok( completionKey == CKEY_FIRST, "Invalid completion key: %lx\n", completionKey );
 803         ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
 804         ok( U(ioSb).Status == STATUS_INVALID_DEVICE_REQUEST, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
 805         ok( completionValue == CVALUE_FIRST, "Invalid completion value: %lx\n", completionValue );
 806     }
 807
 808     count = get_pending_msgs(h);
 809     ok( !count, "Unexpected msg count: %ld\n", count );
 810 }
 811
 812 static void test_iocp_fileio(HANDLE h)
 813 {
 814     static const char pipe_name[] = "\\\\.\\pipe\\iocompletiontestnamedpipe";
 815
 816     IO_STATUS_BLOCK iosb;
 817     FILE_COMPLETION_INFORMATION fci = {h, CKEY_SECOND};
 818     HANDLE hPipeSrv, hPipeClt;
 819     NTSTATUS res;
 820
 821     hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
 822     ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
 823     if (hPipeSrv != INVALID_HANDLE_VALUE )
 824     {
 825         hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
 826         ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
 827         if (hPipeClt != INVALID_HANDLE_VALUE)
 828         {
 829             res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
 830             ok( res == STATUS_INVALID_PARAMETER, "Unexpected NtSetInformationFile on non-overlapped handle: %x\n", res );
 831             CloseHandle(hPipeClt);
 832         }
 833         CloseHandle( hPipeSrv );
 834     }
 835
 836     hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
 837     ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
 838     if (hPipeSrv == INVALID_HANDLE_VALUE )
 839         return;
 840
 841     hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
 842     ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
 843     if (hPipeClt != INVALID_HANDLE_VALUE)
 844     {
 845         OVERLAPPED o = {0,};
 846         BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
 847         DWORD read;
 848         long count;
 849
 850         NTSTATUS res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
 851         ok( res == STATUS_SUCCESS, "NtSetInformationFile failed: %x\n", res );
 852         ok( U(iosb).Status == STATUS_SUCCESS, "iosb.Status invalid: %x\n", U(iosb).Status );
 853
 854         memset( send_buf, 0, TEST_BUF_LEN );
 855         memset( recv_buf, 0xde, TEST_BUF_LEN );
 856         count = get_pending_msgs(h);
 857         ok( !count, "Unexpected msg count: %ld\n", count );
 858         ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
 859         count = get_pending_msgs(h);
 860         ok( !count, "Unexpected msg count: %ld\n", count );
 861         WriteFile( hPipeClt, send_buf, TEST_BUF_LEN, &read, NULL );
 862
 863         if (get_msg(h))
 864         {
 865             ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
 866             ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
 867             ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
 868             ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
 869             ok( !memcmp( send_buf, recv_buf, TEST_BUF_LEN ), "Receive buffer (%x %x %x) did not match send buffer (%x %x %x)\n", recv_buf[0], recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2] );
 870         }
 871         count = get_pending_msgs(h);
 872         ok( !count, "Unexpected msg count: %ld\n", count );
 873
 874         memset( send_buf, 0, TEST_BUF_LEN );
 875         memset( recv_buf, 0xde, TEST_BUF_LEN );
 876         WriteFile( hPipeClt, send_buf, 2, &read, NULL );
 877         count = get_pending_msgs(h);
 878         ok( !count, "Unexpected msg count: %ld\n", count );
 879         ReadFile( hPipeSrv, recv_buf, 2, &read, &o);
 880         count = get_pending_msgs(h);
 881         ok( count == 1, "Unexpected msg count: %ld\n", count );
 882         if (get_msg(h))
 883         {
 884             ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
 885             ok( ioSb.Information == 2, "Invalid ioSb.Information: %ld\n", ioSb.Information );
 886             ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
 887             ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
 888             ok( !memcmp( send_buf, recv_buf, 2 ), "Receive buffer (%x %x) did not match send buffer (%x %x)\n", recv_buf[0], recv_buf[1], send_buf[0], send_buf[1] );
 889         }
 890
 891         ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
 892         CloseHandle( hPipeSrv );
 893         count = get_pending_msgs(h);
 894         ok( count == 1, "Unexpected msg count: %ld\n", count );
 895         if (get_msg(h))
 896         {
 897             ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
 898             ok( ioSb.Information == 0, "Invalid ioSb.Information: %ld\n", ioSb.Information );
 899             /* wine sends wrong status here */
 900             todo_wine ok( U(ioSb).Status == STATUS_PIPE_BROKEN, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
 901             ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
 902         }
 903     }
 904
 905     CloseHandle( hPipeClt );
 906 }
 907
 908 static void test_file_basic_information(void)
 909 {
 910     IO_STATUS_BLOCK io;
 911     FILE_BASIC_INFORMATION fbi;
 912     HANDLE h;
 913     int res;
 914     int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
 915
 916     if (!(h = create_temp_file(0))) return;
 917
 918     /* Check default first */
 919     memset(&fbi, 0, sizeof(fbi));
 920     res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 921     ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
 922     ok ( (fbi.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
 923          "attribute %x not expected\n", fbi.FileAttributes );
 924
 925     /* Then SYSTEM */
 926     /* Clear fbi to avoid setting times */
 927     memset(&fbi, 0, sizeof(fbi));
 928     fbi.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
 929     res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 930     ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
 931
 932     memset(&fbi, 0, sizeof(fbi));
 933     res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 934     ok ( res == STATUS_SUCCESS, "can't get attributes\n");
 935     todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_SYSTEM, "attribute %x not FILE_ATTRIBUTE_SYSTEM\n", fbi.FileAttributes );
 936
 937     /* Then HIDDEN */
 938     memset(&fbi, 0, sizeof(fbi));
 939     fbi.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
 940     res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 941     ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
 942
 943     memset(&fbi, 0, sizeof(fbi));
 944     res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 945     ok ( res == STATUS_SUCCESS, "can't get attributes\n");
 946     todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_HIDDEN, "attribute %x not FILE_ATTRIBUTE_HIDDEN\n", fbi.FileAttributes );
 947
 948     /* Check NORMAL last of all (to make sure we can clear attributes) */
 949     memset(&fbi, 0, sizeof(fbi));
 950     fbi.FileAttributes = FILE_ATTRIBUTE_NORMAL;
 951     res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 952     ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
 953
 954     memset(&fbi, 0, sizeof(fbi));
 955     res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
 956     ok ( res == STATUS_SUCCESS, "can't get attributes\n");
 957     todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_NORMAL, "attribute %x not 0\n", fbi.FileAttributes );
 958
 959     CloseHandle( h );
 960 }
 961
 962 static void test_file_all_information(void)
 963 {
 964     IO_STATUS_BLOCK io;
 965     /* FileAllInformation, like FileNameInformation, has a variable-length pathname
 966      * buffer at the end.  Vista objects with STATUS_BUFFER_OVERFLOW if you
 967      * don't leave enough room there.
 968      */
 969     struct {
 970       FILE_ALL_INFORMATION fai;
 971       WCHAR buf[256];
 972     } fai_buf;
 973     HANDLE h;
 974     int res;
 975     int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
 976
 977     if (!(h = create_temp_file(0))) return;
 978
 979     /* Check default first */
 980     res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
 981     ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
 982     ok ( (fai_buf.fai.BasicInformation.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
 983          "attribute %x not expected\n", fai_buf.fai.BasicInformation.FileAttributes );
 984
 985     /* Then SYSTEM */
 986     /* Clear fbi to avoid setting times */
 987     memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
 988     fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
 989     res = pNtSetInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
 990     ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to set FileAllInformation, res %x\n", res);
 991     res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
 992     ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
 993
 994     memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
 995     res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
 996     ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
 997     todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_SYSTEM, "attribute %x not FILE_ATTRIBUTE_SYSTEM\n", fai_buf.fai.BasicInformation.FileAttributes );
 998
 999     /* Then HIDDEN */
1000     memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
1001     fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1002     res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
1003     ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
1004
1005     memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
1006     res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1007     ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1008     todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_HIDDEN, "attribute %x not FILE_ATTRIBUTE_HIDDEN\n", fai_buf.fai.BasicInformation.FileAttributes );
1009
1010     /* Check NORMAL last of all (to make sure we can clear attributes) */
1011     memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
1012     fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
1013     res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
1014     ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
1015
1016     memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
1017     res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1018     ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1019     todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_NORMAL, "attribute %x not FILE_ATTRIBUTE_NORMAL\n", fai_buf.fai.BasicInformation.FileAttributes );
1020
1021     CloseHandle( h );
1022 }
1023
1024 static void test_file_both_information(void)
1025 {
1026     IO_STATUS_BLOCK io;
1027     FILE_BOTH_DIR_INFORMATION fbi;
1028     HANDLE h;
1029     int res;
1030
1031     if (!(h = create_temp_file(0))) return;
1032
1033     memset(&fbi, 0, sizeof(fbi));
1034     res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBothDirectoryInformation);
1035     ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to query FileBothDirectoryInformation, res %x\n", res);
1036
1037     CloseHandle( h );
1038 }
1039
1040 static void test_iocompletion(void)
1041 {
1042     HANDLE h = INVALID_HANDLE_VALUE;
1043     NTSTATUS res;
1044
1045     res = pNtCreateIoCompletion( &h, IO_COMPLETION_ALL_ACCESS, NULL, 0);
1046
1047     ok( res == 0, "NtCreateIoCompletion anonymous failed: %x\n", res );
1048     ok( h && h != INVALID_HANDLE_VALUE, "Invalid handle returned\n" );
1049
1050     if ( h && h != INVALID_HANDLE_VALUE)
1051     {
1052         test_iocp_setcompletion(h);
1053         test_iocp_fileio(h);
1054         pNtClose(h);
1055     }
1056 }
1057
1058 static void test_file_name_information(void)
1059 {
1060     WCHAR *file_name, *volume_prefix, *expected;
1061     FILE_NAME_INFORMATION *info;
1062     ULONG old_redir = 1, tmp;
1063     UINT file_name_size;
1064     IO_STATUS_BLOCK io;
1065     UINT info_size;
1066     HRESULT hr;
1067     HANDLE h;
1068     UINT len;
1069
1070     /* GetVolumePathName is not present before w2k */
1071     if (!pGetVolumePathNameW) {
1072         win_skip("GetVolumePathNameW not found\n");
1073         return;
1074     }
1075
1076     file_name_size = GetSystemDirectoryW( NULL, 0 );
1077     file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1078     volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1079     expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1080
1081     len = GetSystemDirectoryW( file_name, file_name_size );
1082     ok(len == file_name_size - 1,
1083             "GetSystemDirectoryW returned %u, expected %u.\n",
1084             len, file_name_size - 1);
1085
1086     len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1087     ok(len, "GetVolumePathNameW failed.\n");
1088
1089     len = lstrlenW( volume_prefix );
1090     if (len && volume_prefix[len - 1] == '\\') --len;
1091     memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1092     expected[file_name_size - len - 1] = '\0';
1093
1094     /* A bit more than we actually need, but it keeps the calculation simple. */
1095     info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1096     info = HeapAlloc( GetProcessHeap(), 0, info_size );
1097
1098     if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( TRUE, &old_redir );
1099     h = CreateFileW( file_name, GENERIC_READ,
1100             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1101             NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1102     if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( old_redir, &tmp );
1103     ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1104
1105     hr = pNtQueryInformationFile( h, &io, info, sizeof(*info) - 1, FileNameInformation );
1106     ok(hr == STATUS_INFO_LENGTH_MISMATCH, "NtQueryInformationFile returned %#x.\n", hr);
1107
1108     memset( info, 0xcc, info_size );
1109     hr = pNtQueryInformationFile( h, &io, info, sizeof(*info), FileNameInformation );
1110     ok(hr == STATUS_BUFFER_OVERFLOW, "NtQueryInformationFile returned %#x, expected %#x.\n",
1111             hr, STATUS_BUFFER_OVERFLOW);
1112     ok(U(io).Status == STATUS_BUFFER_OVERFLOW, "io.Status is %#x, expected %#x.\n",
1113             U(io).Status, STATUS_BUFFER_OVERFLOW);
1114     ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u, expected %u.\n",
1115             info->FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
1116     ok(info->FileName[2] == 0xcccc, "info->FileName[2] is %#x, expected 0xcccc.\n", info->FileName[2]);
1117     ok(CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]) == CharLowerW((LPWSTR)(UINT_PTR)expected[1]),
1118             "info->FileName[1] is %p, expected %p.\n",
1119             CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]), CharLowerW((LPWSTR)(UINT_PTR)expected[1]));
1120     ok(io.Information == sizeof(*info), "io.Information is %lu, expected %u.\n", io.Information, sizeof(*info));
1121
1122     memset( info, 0xcc, info_size );
1123     hr = pNtQueryInformationFile( h, &io, info, info_size, FileNameInformation );
1124     ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1125     ok(U(io).Status == STATUS_SUCCESS, "io.Status is %#x, expected %#x.\n", U(io).Status, STATUS_SUCCESS);
1126     ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u, expected %u.\n",
1127             info->FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
1128     ok(info->FileName[info->FileNameLength / sizeof(WCHAR)] == 0xcccc, "info->FileName[%u] is %#x, expected 0xcccc.\n",
1129             info->FileNameLength / sizeof(WCHAR), info->FileName[info->FileNameLength / sizeof(WCHAR)]);
1130     info->FileName[info->FileNameLength / sizeof(WCHAR)] = '\0';
1131     ok(!lstrcmpiW( info->FileName, expected ), "info->FileName is %s, expected %s.\n",
1132             wine_dbgstr_w( info->FileName ), wine_dbgstr_w( expected ));
1133     ok(io.Information == FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength,
1134             "io.Information is %lu, expected %u.\n",
1135             io.Information, FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength);
1136
1137     CloseHandle( h );
1138     HeapFree( GetProcessHeap(), 0, info );
1139     HeapFree( GetProcessHeap(), 0, expected );
1140     HeapFree( GetProcessHeap(), 0, volume_prefix );
1141
1142     if (old_redir || !pGetSystemWow64DirectoryW || !(file_name_size = pGetSystemWow64DirectoryW( NULL, 0 )))
1143     {
1144         skip("Not running on WoW64, skipping test.\n");
1145         HeapFree( GetProcessHeap(), 0, file_name );
1146         return;
1147     }
1148
1149     h = CreateFileW( file_name, GENERIC_READ,
1150             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1151             NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1152     ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1153     HeapFree( GetProcessHeap(), 0, file_name );
1154
1155     file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1156     volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1157     expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*expected) );
1158
1159     len = pGetSystemWow64DirectoryW( file_name, file_name_size );
1160     ok(len == file_name_size - 1,
1161             "GetSystemWow64DirectoryW returned %u, expected %u.\n",
1162             len, file_name_size - 1);
1163
1164     len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1165     ok(len, "GetVolumePathNameW failed.\n");
1166
1167     len = lstrlenW( volume_prefix );
1168     if (len && volume_prefix[len - 1] == '\\') --len;
1169     memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1170     expected[file_name_size - len - 1] = '\0';
1171
1172     info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1173     info = HeapAlloc( GetProcessHeap(), 0, info_size );
1174
1175     memset( info, 0xcc, info_size );
1176     hr = pNtQueryInformationFile( h, &io, info, info_size, FileNameInformation );
1177     ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1178     info->FileName[info->FileNameLength / sizeof(WCHAR)] = '\0';
1179     ok(!lstrcmpiW( info->FileName, expected ), "info->FileName is %s, expected %s.\n",
1180             wine_dbgstr_w( info->FileName ), wine_dbgstr_w( expected ));
1181
1182     CloseHandle( h );
1183     HeapFree( GetProcessHeap(), 0, info );
1184     HeapFree( GetProcessHeap(), 0, expected );
1185     HeapFree( GetProcessHeap(), 0, volume_prefix );
1186     HeapFree( GetProcessHeap(), 0, file_name );
1187 }
1188
1189 static void test_file_all_name_information(void)
1190 {
1191     WCHAR *file_name, *volume_prefix, *expected;
1192     FILE_ALL_INFORMATION *info;
1193     ULONG old_redir = 1, tmp;
1194     UINT file_name_size;
1195     IO_STATUS_BLOCK io;
1196     UINT info_size;
1197     HRESULT hr;
1198     HANDLE h;
1199     UINT len;
1200
1201     /* GetVolumePathName is not present before w2k */
1202     if (!pGetVolumePathNameW) {
1203         win_skip("GetVolumePathNameW not found\n");
1204         return;
1205     }
1206
1207     file_name_size = GetSystemDirectoryW( NULL, 0 );
1208     file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1209     volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1210     expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1211
1212     len = GetSystemDirectoryW( file_name, file_name_size );
1213     ok(len == file_name_size - 1,
1214             "GetSystemDirectoryW returned %u, expected %u.\n",
1215             len, file_name_size - 1);
1216
1217     len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1218     ok(len, "GetVolumePathNameW failed.\n");
1219
1220     len = lstrlenW( volume_prefix );
1221     if (len && volume_prefix[len - 1] == '\\') --len;
1222     memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1223     expected[file_name_size - len - 1] = '\0';
1224
1225     /* A bit more than we actually need, but it keeps the calculation simple. */
1226     info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1227     info = HeapAlloc( GetProcessHeap(), 0, info_size );
1228
1229     if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( TRUE, &old_redir );
1230     h = CreateFileW( file_name, GENERIC_READ,
1231             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1232             NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1233     if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( old_redir, &tmp );
1234     ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1235
1236     hr = pNtQueryInformationFile( h, &io, info, sizeof(*info) - 1, FileAllInformation );
1237     ok(hr == STATUS_INFO_LENGTH_MISMATCH, "NtQueryInformationFile returned %#x, expected %#x.\n",
1238             hr, STATUS_INFO_LENGTH_MISMATCH);
1239
1240     memset( info, 0xcc, info_size );
1241     hr = pNtQueryInformationFile( h, &io, info, sizeof(*info), FileAllInformation );
1242     ok(hr == STATUS_BUFFER_OVERFLOW, "NtQueryInformationFile returned %#x, expected %#x.\n",
1243             hr, STATUS_BUFFER_OVERFLOW);
1244     ok(U(io).Status == STATUS_BUFFER_OVERFLOW, "io.Status is %#x, expected %#x.\n",
1245             U(io).Status, STATUS_BUFFER_OVERFLOW);
1246     ok(info->NameInformation.FileNameLength == lstrlenW( expected ) * sizeof(WCHAR),
1247             "info->NameInformation.FileNameLength is %u, expected %u.\n",
1248             info->NameInformation.FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
1249     ok(info->NameInformation.FileName[2] == 0xcccc,
1250             "info->NameInformation.FileName[2] is %#x, expected 0xcccc.\n", info->NameInformation.FileName[2]);
1251     ok(CharLowerW((LPWSTR)(UINT_PTR)info->NameInformation.FileName[1]) == CharLowerW((LPWSTR)(UINT_PTR)expected[1]),
1252             "info->NameInformation.FileName[1] is %p, expected %p.\n",
1253             CharLowerW((LPWSTR)(UINT_PTR)info->NameInformation.FileName[1]), CharLowerW((LPWSTR)(UINT_PTR)expected[1]));
1254     ok(io.Information == sizeof(*info), "io.Information is %lu, expected %u.\n", io.Information, sizeof(*info));
1255
1256     memset( info, 0xcc, info_size );
1257     hr = pNtQueryInformationFile( h, &io, info, info_size, FileAllInformation );
1258     ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1259     ok(U(io).Status == STATUS_SUCCESS, "io.Status is %#x, expected %#x.\n", U(io).Status, STATUS_SUCCESS);
1260     ok(info->NameInformation.FileNameLength == lstrlenW( expected ) * sizeof(WCHAR),
1261             "info->NameInformation.FileNameLength is %u, expected %u.\n",
1262             info->NameInformation.FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
1263     ok(info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] == 0xcccc,
1264             "info->NameInformation.FileName[%u] is %#x, expected 0xcccc.\n",
1265             info->NameInformation.FileNameLength / sizeof(WCHAR),
1266             info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)]);
1267     info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] = '\0';
1268     ok(!lstrcmpiW( info->NameInformation.FileName, expected ),
1269             "info->NameInformation.FileName is %s, expected %s.\n",
1270             wine_dbgstr_w( info->NameInformation.FileName ), wine_dbgstr_w( expected ));
1271     ok(io.Information == FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName)
1272             + info->NameInformation.FileNameLength,
1273             "io.Information is %lu, expected %u.\n",
1274             io.Information,
1275             FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName) + info->NameInformation.FileNameLength);
1276
1277     CloseHandle( h );
1278     HeapFree( GetProcessHeap(), 0, info );
1279     HeapFree( GetProcessHeap(), 0, expected );
1280     HeapFree( GetProcessHeap(), 0, volume_prefix );
1281
1282     if (old_redir || !pGetSystemWow64DirectoryW || !(file_name_size = pGetSystemWow64DirectoryW( NULL, 0 )))
1283     {
1284         skip("Not running on WoW64, skipping test.\n");
1285         HeapFree( GetProcessHeap(), 0, file_name );
1286         return;
1287     }
1288
1289     h = CreateFileW( file_name, GENERIC_READ,
1290             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1291             NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1292     ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1293     HeapFree( GetProcessHeap(), 0, file_name );
1294
1295     file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1296     volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1297     expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*expected) );
1298
1299     len = pGetSystemWow64DirectoryW( file_name, file_name_size );
1300     ok(len == file_name_size - 1,
1301             "GetSystemWow64DirectoryW returned %u, expected %u.\n",
1302             len, file_name_size - 1);
1303
1304     len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1305     ok(len, "GetVolumePathNameW failed.\n");
1306
1307     len = lstrlenW( volume_prefix );
1308     if (len && volume_prefix[len - 1] == '\\') --len;
1309     memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1310     expected[file_name_size - len - 1] = '\0';
1311
1312     info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1313     info = HeapAlloc( GetProcessHeap(), 0, info_size );
1314
1315     memset( info, 0xcc, info_size );
1316     hr = pNtQueryInformationFile( h, &io, info, info_size, FileAllInformation );
1317     ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1318     info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] = '\0';
1319     ok(!lstrcmpiW( info->NameInformation.FileName, expected ), "info->NameInformation.FileName is %s, expected %s.\n",
1320             wine_dbgstr_w( info->NameInformation.FileName ), wine_dbgstr_w( expected ));
1321
1322     CloseHandle( h );
1323     HeapFree( GetProcessHeap(), 0, info );
1324     HeapFree( GetProcessHeap(), 0, expected );
1325     HeapFree( GetProcessHeap(), 0, volume_prefix );
1326     HeapFree( GetProcessHeap(), 0, file_name );
1327 }
1328
1329 START_TEST(file)
1330 {
1331     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
1332     HMODULE hntdll = GetModuleHandleA("ntdll.dll");
1333     if (!hntdll)
1334     {
1335         skip("not running on NT, skipping test\n");
1336         return;
1337     }
1338
1339     pGetVolumePathNameW = (void *)GetProcAddress(hkernel32, "GetVolumePathNameW");
1340     pGetSystemWow64DirectoryW = (void *)GetProcAddress(hkernel32, "GetSystemWow64DirectoryW");
1341
1342     pRtlFreeUnicodeString   = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
1343     pRtlInitUnicodeString   = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
1344     pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
1345     pRtlWow64EnableFsRedirectionEx = (void *)GetProcAddress(hntdll, "RtlWow64EnableFsRedirectionEx");
1346     pNtCreateMailslotFile   = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
1347     pNtOpenFile             = (void *)GetProcAddress(hntdll, "NtOpenFile");
1348     pNtDeleteFile           = (void *)GetProcAddress(hntdll, "NtDeleteFile");
1349     pNtReadFile             = (void *)GetProcAddress(hntdll, "NtReadFile");
1350     pNtWriteFile            = (void *)GetProcAddress(hntdll, "NtWriteFile");
1351     pNtCancelIoFile         = (void *)GetProcAddress(hntdll, "NtCancelIoFile");
1352     pNtCancelIoFileEx       = (void *)GetProcAddress(hntdll, "NtCancelIoFileEx");
1353     pNtClose                = (void *)GetProcAddress(hntdll, "NtClose");
1354     pNtCreateIoCompletion   = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
1355     pNtOpenIoCompletion     = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
1356     pNtQueryIoCompletion    = (void *)GetProcAddress(hntdll, "NtQueryIoCompletion");
1357     pNtRemoveIoCompletion   = (void *)GetProcAddress(hntdll, "NtRemoveIoCompletion");
1358     pNtSetIoCompletion      = (void *)GetProcAddress(hntdll, "NtSetIoCompletion");
1359     pNtSetInformationFile   = (void *)GetProcAddress(hntdll, "NtSetInformationFile");
1360     pNtQueryInformationFile = (void *)GetProcAddress(hntdll, "NtQueryInformationFile");
1361     pNtQueryDirectoryFile   = (void *)GetProcAddress(hntdll, "NtQueryDirectoryFile");
1362
1363     open_file_test();
1364     delete_file_test();
1365     read_file_test();
1366     nt_mailslot_test();
1367     test_iocompletion();
1368     test_file_basic_information();
1369     test_file_all_information();
1370     test_file_both_information();
1371     test_file_name_information();
1372     test_file_all_name_information();
1373 }