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