?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Fix overlapping shared and exclusive locks support.
[wine/multimedia.git] / dlls / kernel32 / tests / file.c
bloba720d52b97a637c4a9607f269f46d4c8ce747a1f
1 /*
2 * Unit tests for file functions in Wine
3 *
4 * Copyright (c) 2002, 2004 Jakob Eriksson
5 * Copyright (c) 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 */
22
23 /* ReplaceFile requires Windows 2000 or newer */
24 #define _WIN32_WINNT 0x0500
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <time.h>
29 #include <stdio.h>
30
31 #include "wine/test.h"
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winerror.h"
35
36 static HANDLE (WINAPI *pFindFirstFileExA)(LPCSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
37 static BOOL (WINAPI *pReplaceFileA)(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
38 static BOOL (WINAPI *pReplaceFileW)(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
39 static UINT (WINAPI *pGetSystemWindowsDirectoryA)(LPSTR, UINT);
40 static BOOL (WINAPI *pGetVolumeNameForVolumeMountPointA)(LPCSTR, LPSTR, DWORD);
41 static DWORD (WINAPI *pQueueUserAPC)(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
42
43 /* keep filename and filenameW the same */
44 static const char filename[] = "testfile.xxx";
45 static const WCHAR filenameW[] = { 't','e','s','t','f','i','l','e','.','x','x','x',0 };
46 static const char sillytext[] =
47 "en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
48 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
49 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
50 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
51 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
52 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
53 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
54 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
55 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
56 "sdlkfjasdlkfj a dslkj adsklf \n \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
57
58 struct test_list {
59 const char *file; /* file string to test */
60 const DWORD err; /* Win NT and further error code */
61 const LONG err2; /* Win 9x & ME error code or -1 */
62 const DWORD options; /* option flag to use for open */
63 const BOOL todo_flag; /* todo_wine indicator */
64 } ;
65
66 static void InitFunctionPointers(void)
67 {
68 HMODULE hkernel32 = GetModuleHandleA("kernel32");
69
70 pFindFirstFileExA=(void*)GetProcAddress(hkernel32, "FindFirstFileExA");
71 pReplaceFileA=(void*)GetProcAddress(hkernel32, "ReplaceFileA");
72 pReplaceFileW=(void*)GetProcAddress(hkernel32, "ReplaceFileW");
73 pGetSystemWindowsDirectoryA=(void*)GetProcAddress(hkernel32, "GetSystemWindowsDirectoryA");
74 pGetVolumeNameForVolumeMountPointA = (void *) GetProcAddress(hkernel32, "GetVolumeNameForVolumeMountPointA");
75 pQueueUserAPC = (void *) GetProcAddress(hkernel32, "QueueUserAPC");
76 }
77
78 static void test__hread( void )
79 {
80 HFILE filehandle;
81 char buffer[10000];
82 LONG bytes_read;
83 LONG bytes_wanted;
84 LONG i;
85 BOOL ret;
86
87 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
88 DeleteFileA( filename );
89 filehandle = _lcreat( filename, 0 );
90 if (filehandle == HFILE_ERROR)
91 {
92 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
93 return;
94 }
95
96 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
97
98 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
99
100 filehandle = _lopen( filename, OF_READ );
101
102 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError( ) );
103
104 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
105
106 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
107
108 for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
109 {
110 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
111 ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
112 for (i = 0; i < bytes_wanted; i++)
113 {
114 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
115 }
116 }
117
118 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
119
120 ret = DeleteFileA( filename );
121 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
122 }
123
124
125 static void test__hwrite( void )
126 {
127 HFILE filehandle;
128 char buffer[10000];
129 LONG bytes_read;
130 LONG bytes_written;
131 ULONG blocks;
132 LONG i;
133 char *contents;
134 HLOCAL memory_object;
135 char checksum[1];
136 BOOL ret;
137
138 filehandle = _lcreat( filename, 0 );
139 if (filehandle == HFILE_ERROR)
140 {
141 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
142 return;
143 }
144
145 ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
146
147 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
148
149 filehandle = _lopen( filename, OF_READ );
150
151 bytes_read = _hread( filehandle, buffer, 1);
152
153 ok( 0 == bytes_read, "file read size error\n" );
154
155 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
156
157 filehandle = _lopen( filename, OF_READWRITE );
158
159 bytes_written = 0;
160 checksum[0] = '\0';
161 srand( (unsigned)time( NULL ) );
162 for (blocks = 0; blocks < 100; blocks++)
163 {
164 for (i = 0; i < (LONG)sizeof( buffer ); i++)
165 {
166 buffer[i] = rand( );
167 checksum[0] = checksum[0] + buffer[i];
168 }
169 ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
170 bytes_written = bytes_written + sizeof( buffer );
171 }
172
173 ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
174 bytes_written++;
175
176 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
177
178 memory_object = LocalAlloc( LPTR, bytes_written );
179
180 ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
181
182 contents = LocalLock( memory_object );
183 ok( NULL != contents, "LocalLock whines\n" );
184
185 filehandle = _lopen( filename, OF_READ );
186
187 contents = LocalLock( memory_object );
188 ok( NULL != contents, "LocalLock whines\n" );
189
190 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
191
192 checksum[0] = '\0';
193 i = 0;
194 do
195 {
196 checksum[0] = checksum[0] + contents[i];
197 i++;
198 }
199 while (i < bytes_written - 1);
200
201 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
202
203 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
204
205 ret = DeleteFileA( filename );
206 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
207
208 LocalFree( contents );
209 }
210
211
212 static void test__lclose( void )
213 {
214 HFILE filehandle;
215 BOOL ret;
216
217 filehandle = _lcreat( filename, 0 );
218 if (filehandle == HFILE_ERROR)
219 {
220 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
221 return;
222 }
223
224 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
225
226 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
227
228 ret = DeleteFileA( filename );
229 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
230 }
231
232
233 static void test__lcreat( void )
234 {
235 HFILE filehandle;
236 char buffer[10000];
237 WIN32_FIND_DATAA search_results;
238 char slashname[] = "testfi/";
239 int err;
240 HANDLE find;
241 BOOL ret;
242
243 filehandle = _lcreat( filename, 0 );
244 if (filehandle == HFILE_ERROR)
245 {
246 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
247 return;
248 }
249
250 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
251
252 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
253
254 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
255
256 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
257
258 find = FindFirstFileA( filename, &search_results );
259 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
260 FindClose( find );
261
262 ret = DeleteFileA(filename);
263 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError());
264
265 filehandle = _lcreat( filename, 1 ); /* readonly */
266 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
267
268 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
269
270 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
271
272 find = FindFirstFileA( filename, &search_results );
273 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
274 FindClose( find );
275
276 ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
277
278 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
279
280 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
281
282 filehandle = _lcreat( filename, 2 );
283 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
284
285 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
286
287 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
288
289 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
290
291 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
292
293 find = FindFirstFileA( filename, &search_results );
294 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
295 FindClose( find );
296
297 ret = DeleteFileA( filename );
298 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
299
300 filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
301 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
302
303 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
304
305 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
306
307 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
308
309 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
310
311 find = FindFirstFileA( filename, &search_results );
312 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
313 FindClose( find );
314
315 ret = DeleteFileA( filename );
316 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
317
318 filehandle=_lcreat (slashname, 0); /* illegal name */
319 if (HFILE_ERROR==filehandle) {
320 err=GetLastError ();
321 ok (err==ERROR_INVALID_NAME || err==ERROR_PATH_NOT_FOUND,
322 "creating file \"%s\" failed with error %d\n", slashname, err);
323 } else { /* only NT succeeds */
324 _lclose(filehandle);
325 find=FindFirstFileA (slashname, &search_results);
326 if (INVALID_HANDLE_VALUE!=find)
327 {
328 ret = FindClose (find);
329 ok (0 != ret, "FindClose complains (%d)\n", GetLastError ());
330 slashname[strlen(slashname)-1]=0;
331 ok (!strcmp (slashname, search_results.cFileName),
332 "found unexpected name \"%s\"\n", search_results.cFileName);
333 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
334 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
335 search_results.dwFileAttributes);
336 }
337 ret = DeleteFileA( slashname );
338 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
339 }
340
341 filehandle=_lcreat (filename, 8); /* illegal attribute */
342 if (HFILE_ERROR==filehandle)
343 ok (0, "couldn't create volume label \"%s\"\n", filename);
344 else {
345 _lclose(filehandle);
346 find=FindFirstFileA (filename, &search_results);
347 if (INVALID_HANDLE_VALUE==find)
348 ok (0, "file \"%s\" not found\n", filename);
349 else {
350 ret = FindClose(find);
351 ok ( 0 != ret, "FindClose complains (%d)\n", GetLastError ());
352 ok (!strcmp (filename, search_results.cFileName),
353 "found unexpected name \"%s\"\n", search_results.cFileName);
354 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
355 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
356 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
357 search_results.dwFileAttributes);
358 }
359 ret = DeleteFileA( filename );
360 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
361 }
362 }
363
364
365 static void test__llseek( void )
366 {
367 INT i;
368 HFILE filehandle;
369 char buffer[1];
370 LONG bytes_read;
371 BOOL ret;
372
373 filehandle = _lcreat( filename, 0 );
374 if (filehandle == HFILE_ERROR)
375 {
376 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
377 return;
378 }
379
380 for (i = 0; i < 400; i++)
381 {
382 ok( _hwrite( filehandle, sillytext, strlen( sillytext ) ) != -1, "_hwrite complains\n" );
383 }
384 ok( _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ) != -1, "should be able to seek\n" );
385 ok( _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ) != -1, "should be able to seek\n" );
386
387 bytes_read = _hread( filehandle, buffer, 1);
388 ok( 1 == bytes_read, "file read size error\n" );
389 ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
390 ok( _llseek( filehandle, -400 * (LONG)strlen( sillytext ), FILE_END ) != -1, "should be able to seek\n" );
391
392 bytes_read = _hread( filehandle, buffer, 1);
393 ok( 1 == bytes_read, "file read size error\n" );
394 ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
395 ok( _llseek( filehandle, 1000000, FILE_END ) != -1, "should be able to seek past file; poor, poor Windows programmers\n" );
396 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
397
398 ret = DeleteFileA( filename );
399 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
400 }
401
402
403 static void test__llopen( void )
404 {
405 HFILE filehandle;
406 UINT bytes_read;
407 char buffer[10000];
408 BOOL ret;
409
410 filehandle = _lcreat( filename, 0 );
411 if (filehandle == HFILE_ERROR)
412 {
413 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
414 return;
415 }
416
417 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
418 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
419
420 filehandle = _lopen( filename, OF_READ );
421 ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
422 bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
423 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
424 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
425
426 filehandle = _lopen( filename, OF_READWRITE );
427 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
428 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
429 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
430 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
431
432 filehandle = _lopen( filename, OF_WRITE );
433 ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
434 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
435 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
436
437 ret = DeleteFileA( filename );
438 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
439 /* TODO - add tests for the SHARE modes - use two processes to pull this one off */
440 }
441
442
443 static void test__lread( void )
444 {
445 HFILE filehandle;
446 char buffer[10000];
447 UINT bytes_read;
448 UINT bytes_wanted;
449 UINT i;
450 BOOL ret;
451
452 filehandle = _lcreat( filename, 0 );
453 if (filehandle == HFILE_ERROR)
454 {
455 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
456 return;
457 }
458
459 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
460
461 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
462
463 filehandle = _lopen( filename, OF_READ );
464
465 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError());
466
467 bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
468
469 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
470
471 for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
472 {
473 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
474 ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
475 for (i = 0; i < bytes_wanted; i++)
476 {
477 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
478 }
479 }
480
481 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
482
483 ret = DeleteFileA( filename );
484 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
485 }
486
487
488 static void test__lwrite( void )
489 {
490 HFILE filehandle;
491 char buffer[10000];
492 UINT bytes_read;
493 UINT bytes_written;
494 UINT blocks;
495 INT i;
496 char *contents;
497 HLOCAL memory_object;
498 char checksum[1];
499 BOOL ret;
500
501 filehandle = _lcreat( filename, 0 );
502 if (filehandle == HFILE_ERROR)
503 {
504 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
505 return;
506 }
507
508 ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
509
510 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
511
512 filehandle = _lopen( filename, OF_READ );
513
514 bytes_read = _hread( filehandle, buffer, 1);
515
516 ok( 0 == bytes_read, "file read size error\n" );
517
518 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
519
520 filehandle = _lopen( filename, OF_READWRITE );
521
522 bytes_written = 0;
523 checksum[0] = '\0';
524 srand( (unsigned)time( NULL ) );
525 for (blocks = 0; blocks < 100; blocks++)
526 {
527 for (i = 0; i < (INT)sizeof( buffer ); i++)
528 {
529 buffer[i] = rand( );
530 checksum[0] = checksum[0] + buffer[i];
531 }
532 ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
533 bytes_written = bytes_written + sizeof( buffer );
534 }
535
536 ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
537 bytes_written++;
538
539 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
540
541 memory_object = LocalAlloc( LPTR, bytes_written );
542
543 ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
544
545 contents = LocalLock( memory_object );
546 ok( NULL != contents, "LocalLock whines\n" );
547
548 filehandle = _lopen( filename, OF_READ );
549
550 contents = LocalLock( memory_object );
551 ok( NULL != contents, "LocalLock whines\n" );
552
553 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
554
555 checksum[0] = '\0';
556 i = 0;
557 do
558 {
559 checksum[0] += contents[i];
560 i++;
561 }
562 while (i < bytes_written - 1);
563
564 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
565
566 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
567
568 ret = DeleteFileA( filename );
569 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
570
571 LocalFree( contents );
572 }
573
574 static void test_CopyFileA(void)
575 {
576 char temp_path[MAX_PATH];
577 char source[MAX_PATH], dest[MAX_PATH];
578 static const char prefix[] = "pfx";
579 HANDLE hfile;
580 HANDLE hmapfile;
581 FILETIME ft1, ft2;
582 char buf[10];
583 DWORD ret;
584 BOOL retok;
585
586 ret = GetTempPathA(MAX_PATH, temp_path);
587 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
588 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
589
590 ret = GetTempFileNameA(temp_path, prefix, 0, source);
591 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
592
593 ret = MoveFileA(source, source);
594 todo_wine ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
595
596 /* copying a file to itself must fail */
597 retok = CopyFileA(source, source, FALSE);
598 ok( !retok && (GetLastError() == ERROR_SHARING_VIOLATION || broken(GetLastError() == ERROR_FILE_EXISTS) /* Win 9x */),
599 "copying a file to itself didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
600
601 /* make the source have not zero size */
602 hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
603 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
604 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
605 ok( retok && ret == sizeof(prefix),
606 "WriteFile error %d\n", GetLastError());
607 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
608 /* get the file time and change it to prove the difference */
609 ret = GetFileTime(hfile, NULL, NULL, &ft1);
610 ok( ret, "GetFileTime error %d\n", GetLastError());
611 ft1.dwLowDateTime -= 600000000; /* 60 second */
612 ret = SetFileTime(hfile, NULL, NULL, &ft1);
613 ok( ret, "SetFileTime error %d\n", GetLastError());
614 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
615 CloseHandle(hfile);
616
617 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
618 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
619
620 SetLastError(0xdeadbeef);
621 ret = CopyFileA(source, dest, TRUE);
622 ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
623 "CopyFileA: unexpected error %d\n", GetLastError());
624
625 ret = CopyFileA(source, dest, FALSE);
626 ok(ret, "CopyFileA: error %d\n", GetLastError());
627
628 /* copying from a read-locked source fails */
629 hfile = CreateFileA(source, GENERIC_READ, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
630 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
631 retok = CopyFileA(source, dest, FALSE);
632 ok(!retok && GetLastError() == ERROR_SHARING_VIOLATION,
633 "copying from a read-locked file succeeded when it shouldn't have\n");
634 /* in addition, the source is opened before the destination */
635 retok = CopyFileA("25f99d3b-4ba4-4f66-88f5-2906886993cc", dest, FALSE);
636 ok(!retok && GetLastError() == ERROR_FILE_NOT_FOUND,
637 "copying from a file that doesn't exist failed in an unexpected way (ret=%d, err=%d)\n", retok, GetLastError());
638 CloseHandle(hfile);
639
640 /* copying from a r+w opened, r shared source succeeds */
641 hfile = CreateFileA(source, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
642 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
643 retok = CopyFileA(source, dest, FALSE);
644 ok(retok,
645 "copying from an r+w opened and r shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
646 CloseHandle(hfile);
647
648 /* copying from a delete-locked source is unreliable */
649 hfile = CreateFileA(source, DELETE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
650 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
651 retok = CopyFileA(source, dest, FALSE);
652 ok((!retok && GetLastError() == ERROR_SHARING_VIOLATION) || broken(retok) /* 98, Vista, 2k8, 7 */,
653 "copying from a delete-locked file failed (ret=%d, err=%d)\n", retok, GetLastError());
654 CloseHandle(hfile);
655
656 /* copying to a write-locked destination fails */
657 hfile = CreateFileA(dest, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
658 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
659 retok = CopyFileA(source, dest, FALSE);
660 ok(!retok && GetLastError() == ERROR_SHARING_VIOLATION,
661 "copying to a write-locked file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
662 CloseHandle(hfile);
663
664 /* copying to a r+w opened, w shared destination mostly succeeds */
665 hfile = CreateFileA(dest, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
666 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
667 retok = CopyFileA(source, dest, FALSE);
668 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
669 "copying to a r+w opened and w shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
670 CloseHandle(hfile);
671
672 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
673 hfile = CreateFileA(dest, DELETE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, 0);
674 ok(hfile != INVALID_HANDLE_VALUE || broken(GetLastError() == ERROR_INVALID_PARAMETER) /* Win 9x */,
675 "failed to open destination file, error %d\n", GetLastError());
676 if (hfile != INVALID_HANDLE_VALUE)
677 {
678 retok = CopyFileA(source, dest, FALSE);
679 ok(!retok && GetLastError() == ERROR_SHARING_VIOLATION,
680 "copying to a delete-locked shared file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
681 CloseHandle(hfile);
682 }
683
684 /* copy to a file that's opened the way Wine opens the source */
685 hfile = CreateFileA(dest, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
686 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
687 retok = CopyFileA(source, dest, FALSE);
688 ok(retok || broken(GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
689 "copying to a file opened the way Wine opens the source failed (ret=%d, err=%d)\n", retok, GetLastError());
690 CloseHandle(hfile);
691
692 /* make sure that destination has correct size */
693 hfile = CreateFileA(dest, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
694 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
695 ret = GetFileSize(hfile, NULL);
696 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
697
698 /* make sure that destination has the same filetime */
699 ret = GetFileTime(hfile, NULL, NULL, &ft2);
700 ok( ret, "GetFileTime error %d\n", GetLastError());
701 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
702
703 SetLastError(0xdeadbeef);
704 ret = CopyFileA(source, dest, FALSE);
705 ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION,
706 "CopyFileA: ret = %d, unexpected error %d\n", ret, GetLastError());
707
708 /* make sure that destination still has correct size */
709 ret = GetFileSize(hfile, NULL);
710 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
711 retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
712 ok( retok && ret == sizeof(prefix),
713 "ReadFile: error %d\n", GetLastError());
714 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
715
716 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
717 hmapfile = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
718 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
719
720 ret = CopyFileA(source, dest, FALSE);
721 ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION,
722 "CopyFileA with mapped dest file: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
723
724 CloseHandle(hmapfile);
725 CloseHandle(hfile);
726
727 hfile = CreateFileA(dest, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
728 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
729
730 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
731 hmapfile = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
732 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
733
734 ret = CopyFileA(source, dest, FALSE);
735 ok(!ret, "CopyFileA: expected failure\n");
736 ok(GetLastError() == ERROR_USER_MAPPED_FILE ||
737 broken(GetLastError() == ERROR_SHARING_VIOLATION), /* Win9x */
738 "CopyFileA with mapped dest file: expected ERROR_USER_MAPPED_FILE, got %d\n", GetLastError());
739
740 CloseHandle(hmapfile);
741 CloseHandle(hfile);
742
743 ret = DeleteFileA(source);
744 ok(ret, "DeleteFileA: error %d\n", GetLastError());
745 ret = DeleteFileA(dest);
746 ok(ret, "DeleteFileA: error %d\n", GetLastError());
747 }
748
749 static void test_CopyFileW(void)
750 {
751 WCHAR temp_path[MAX_PATH];
752 WCHAR source[MAX_PATH], dest[MAX_PATH];
753 static const WCHAR prefix[] = {'p','f','x',0};
754 DWORD ret;
755
756 ret = GetTempPathW(MAX_PATH, temp_path);
757 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
758 {
759 win_skip("GetTempPathW is not available\n");
760 return;
761 }
762 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
763 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
764
765 ret = GetTempFileNameW(temp_path, prefix, 0, source);
766 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
767
768 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
769 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
770
771 ret = CopyFileW(source, dest, TRUE);
772 ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
773 "CopyFileW: unexpected error %d\n", GetLastError());
774
775 ret = CopyFileW(source, dest, FALSE);
776 ok(ret, "CopyFileW: error %d\n", GetLastError());
777
778 ret = DeleteFileW(source);
779 ok(ret, "DeleteFileW: error %d\n", GetLastError());
780 ret = DeleteFileW(dest);
781 ok(ret, "DeleteFileW: error %d\n", GetLastError());
782 }
783
784
785 /*
786 * Debugging routine to dump a buffer in a hexdump-like fashion.
787 */
788 static void dumpmem(unsigned char *mem, int len)
789 {
790 int x = 0;
791 char hex[49], *p;
792 char txt[17], *c;
793
794 while (x < len)
795 {
796 p = hex;
797 c = txt;
798 do {
799 p += sprintf(p, "%02hhx ", mem[x]);
800 *c++ = (mem[x] >= 32 && mem[x] <= 127) ? mem[x] : '.';
801 } while (++x % 16 && x < len);
802 *c = '\0';
803 trace("%04x: %-48s- %s\n", x, hex, txt);
804 }
805 }
806
807 static void test_CreateFileA(void)
808 {
809 HANDLE hFile;
810 char temp_path[MAX_PATH], dirname[MAX_PATH];
811 char filename[MAX_PATH];
812 static const char prefix[] = "pfx";
813 char windowsdir[MAX_PATH];
814 char Volume_1[MAX_PATH];
815 unsigned char buffer[512];
816 char directory[] = "removeme";
817 static const char nt_drive[] = "\\\\?\\A:";
818 DWORD i, ret, len;
819 struct test_list p[] = {
820 {"", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dir as file w \ */
821 {"", ERROR_SUCCESS, ERROR_PATH_NOT_FOUND, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* dir as dir w \ */
822 {"a", ERROR_FILE_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* non-exist file */
823 {"a\\", ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, FILE_ATTRIBUTE_NORMAL, FALSE }, /* non-exist dir */
824 {"removeme", ERROR_ACCESS_DENIED, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* exist dir w/o \ */
825 {"removeme\\", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* exst dir w \ */
826 {"c:", ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, FILE_ATTRIBUTE_NORMAL, FALSE }, /* device in file namespace */
827 {"c:", ERROR_SUCCESS, ERROR_PATH_NOT_FOUND, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* device in file namespace as dir */
828 {"c:\\", ERROR_PATH_NOT_FOUND, ERROR_ACCESS_DENIED, FILE_ATTRIBUTE_NORMAL, TRUE }, /* root dir w \ */
829 {"c:\\", ERROR_SUCCESS, ERROR_ACCESS_DENIED, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* root dir w \ as dir */
830 {"\\\\?\\c:", ERROR_SUCCESS, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL,FALSE }, /* dev namespace drive */
831 {"\\\\?\\c:\\", ERROR_PATH_NOT_FOUND, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dev namespace drive w \ */
832 {NULL, 0, -1, 0, FALSE}
833 };
834 BY_HANDLE_FILE_INFORMATION Finfo;
835
836 ret = GetTempPathA(MAX_PATH, temp_path);
837 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
838 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
839
840 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
841 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
842
843 SetLastError(0xdeadbeef);
844 hFile = CreateFileA(filename, GENERIC_READ, 0, NULL,
845 CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
846 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
847 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
848
849 SetLastError(0xdeadbeef);
850 hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
851 CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
852 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
853 "hFile %p, last error %u\n", hFile, GetLastError());
854
855 CloseHandle(hFile);
856
857 SetLastError(0xdeadbeef);
858 hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
859 OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
860 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
861 "hFile %p, last error %u\n", hFile, GetLastError());
862
863 CloseHandle(hFile);
864
865 ret = DeleteFileA(filename);
866 ok(ret, "DeleteFileA: error %d\n", GetLastError());
867
868 SetLastError(0xdeadbeef);
869 hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
870 OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
871 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == 0,
872 "hFile %p, last error %u\n", hFile, GetLastError());
873
874 CloseHandle(hFile);
875
876 ret = DeleteFileA(filename);
877 ok(ret, "DeleteFileA: error %d\n", GetLastError());
878
879 SetLastError(0xdeadbeef);
880 hFile = CreateFileA("c:\\*.*", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
881 ok(hFile == INVALID_HANDLE_VALUE, "hFile should have been INVALID_HANDLE_VALUE\n");
882 ok(GetLastError() == ERROR_INVALID_NAME ||
883 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* Win98 */
884 "LastError should have been ERROR_INVALID_NAME or ERROR_FILE_NOT_FOUND but got %u\n", GetLastError());
885
886 /* get windows drive letter */
887 ret = GetWindowsDirectory(windowsdir, sizeof(windowsdir));
888 ok(ret < sizeof(windowsdir), "windowsdir is abnormally long!\n");
889 ok(ret != 0, "GetWindowsDirectory: error %d\n", GetLastError());
890
891 /* test error return codes from CreateFile for some cases */
892 ret = GetTempPathA(MAX_PATH, temp_path);
893 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
894 strcpy(dirname, temp_path);
895 strcat(dirname, directory);
896 ret = CreateDirectory(dirname, NULL);
897 ok( ret, "Createdirectory failed, gle=%d\n", GetLastError() );
898 /* set current drive & directory to known location */
899 SetCurrentDirectoryA( temp_path );
900 i = 0;
901 while (p[i].file)
902 {
903 filename[0] = 0;
904 /* update the drive id in the table entry with the current one */
905 if (p[i].file[1] == ':')
906 {
907 strcpy(filename, p[i].file);
908 filename[0] = windowsdir[0];
909 }
910 else if (p[i].file[0] == '\\' && p[i].file[5] == ':')
911 {
912 strcpy(filename, p[i].file);
913 filename[4] = windowsdir[0];
914 }
915 else
916 {
917 /* prefix the table entry with the current temp directory */
918 strcpy(filename, temp_path);
919 strcat(filename, p[i].file);
920 }
921 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
922 FILE_SHARE_READ | FILE_SHARE_WRITE,
923 NULL, OPEN_EXISTING,
924 p[i].options, NULL );
925 /* if we get ACCESS_DENIED when we do not expect it, assume
926 * no access to the volume
927 */
928 if (hFile == INVALID_HANDLE_VALUE &&
929 GetLastError() == ERROR_ACCESS_DENIED &&
930 p[i].err != ERROR_ACCESS_DENIED)
931 {
932 if (p[i].todo_flag)
933 skip("Either no authority to volume, or is todo_wine for %s err=%d should be %d\n", filename, GetLastError(), p[i].err);
934 else
935 skip("Do not have authority to access volumes. Test for %s skipped\n", filename);
936 }
937 /* otherwise validate results with expectations */
938 else if (p[i].todo_flag)
939 todo_wine ok(
940 (hFile == INVALID_HANDLE_VALUE &&
941 (p[i].err == GetLastError() || p[i].err2 == GetLastError())) ||
942 (hFile != INVALID_HANDLE_VALUE && p[i].err == ERROR_SUCCESS),
943 "CreateFileA failed on %s, hFile %p, err=%u, should be %u\n",
944 filename, hFile, GetLastError(), p[i].err);
945 else
946 ok(
947 (hFile == INVALID_HANDLE_VALUE &&
948 (p[i].err == GetLastError() || p[i].err2 == GetLastError())) ||
949 (hFile != INVALID_HANDLE_VALUE && p[i].err == ERROR_SUCCESS),
950 "CreateFileA failed on %s, hFile %p, err=%u, should be %u\n",
951 filename, hFile, GetLastError(), p[i].err);
952 if (hFile != INVALID_HANDLE_VALUE)
953 CloseHandle( hFile );
954 i++;
955 }
956 ret = RemoveDirectoryA(dirname);
957 ok(ret, "RemoveDirectoryA: error %d\n", GetLastError());
958
959
960 /* test opening directory as a directory */
961 hFile = CreateFileA( temp_path, GENERIC_READ,
962 FILE_SHARE_READ,
963 NULL,
964 OPEN_EXISTING,
965 FILE_FLAG_BACKUP_SEMANTICS, NULL );
966 if (hFile != INVALID_HANDLE_VALUE && GetLastError() != ERROR_PATH_NOT_FOUND)
967 {
968 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_SUCCESS,
969 "CreateFileA did not work, last error %u on volume <%s>\n",
970 GetLastError(), temp_path );
971
972 if (hFile != INVALID_HANDLE_VALUE)
973 {
974 ret = GetFileInformationByHandle( hFile, &Finfo );
975 if (ret)
976 {
977 ok(Finfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY,
978 "CreateFileA probably did not open temp directory %s correctly\n file information does not include FILE_ATTRIBUTE_DIRECTORY, actual=0x%08x\n",
979 temp_path, Finfo.dwFileAttributes);
980 }
981 CloseHandle( hFile );
982 }
983 }
984 else
985 skip("Probable Win9x, got ERROR_PATH_NOT_FOUND w/ FILE_FLAG_BACKUP_SEMANTICS or %s\n", temp_path);
986
987
988 /* *** Test opening volumes/devices using drive letter *** */
989
990 /* test using drive letter in non-rewrite format without trailing \ */
991 /* this should work */
992 strcpy(filename, nt_drive);
993 filename[4] = windowsdir[0];
994 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
995 FILE_SHARE_READ | FILE_SHARE_WRITE,
996 NULL, OPEN_EXISTING,
997 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL );
998 if (hFile != INVALID_HANDLE_VALUE ||
999 (GetLastError() != ERROR_ACCESS_DENIED && GetLastError() != ERROR_BAD_NETPATH))
1000 {
1001 /* if we have adm rights to volume, then try rest of tests */
1002 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1003 filename, GetLastError());
1004 if (hFile != INVALID_HANDLE_VALUE)
1005 {
1006 /* if we opened the volume/device, try to read it. Since it */
1007 /* opened, we should be able to read it. We don't care about*/
1008 /* what the data is at this time. */
1009 len = 512;
1010 ret = ReadFile( hFile, buffer, len, &len, NULL );
1011 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1012 GetLastError(), ret, filename);
1013 if (ret)
1014 {
1015 trace("buffer is\n");
1016 dumpmem(buffer, 64);
1017 }
1018 CloseHandle( hFile );
1019 }
1020
1021 /* test using drive letter with trailing \ and in non-rewrite */
1022 /* this should not work */
1023 strcpy(filename, nt_drive);
1024 filename[4] = windowsdir[0];
1025 strcat( filename, "\\" );
1026 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1027 FILE_SHARE_READ | FILE_SHARE_WRITE,
1028 NULL, OPEN_EXISTING,
1029 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL );
1030 todo_wine
1031 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
1032 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1033 filename, GetLastError());
1034 if (hFile != INVALID_HANDLE_VALUE)
1035 CloseHandle( hFile );
1036
1037 /* test using temp path with trailing \ and in non-rewrite as dir */
1038 /* this should work */
1039 strcpy(filename, nt_drive);
1040 filename[4] = 0;
1041 strcat( filename, temp_path );
1042 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1043 FILE_SHARE_READ | FILE_SHARE_WRITE,
1044 NULL, OPEN_EXISTING,
1045 FILE_FLAG_BACKUP_SEMANTICS, NULL );
1046 ok(hFile != INVALID_HANDLE_VALUE,
1047 "CreateFileA should have worked on %s, but got %u\n",
1048 filename, GetLastError());
1049 if (hFile != INVALID_HANDLE_VALUE)
1050 CloseHandle( hFile );
1051
1052 /* test using drive letter without trailing \ and in device ns */
1053 /* this should work */
1054 strcpy(filename, nt_drive);
1055 filename[4] = windowsdir[0];
1056 filename[2] = '.';
1057 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1058 FILE_SHARE_READ | FILE_SHARE_WRITE,
1059 NULL, OPEN_EXISTING,
1060 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL );
1061 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1062 filename, GetLastError());
1063 if (hFile != INVALID_HANDLE_VALUE)
1064 CloseHandle( hFile );
1065 }
1066 /* If we see ERROR_BAD_NETPATH then on Win9x or WinME, so skip */
1067 else if (GetLastError() == ERROR_BAD_NETPATH)
1068 skip("Probable Win9x, got ERROR_BAD_NETPATH (53)\n");
1069 else
1070 skip("Do not have authority to access volumes. Tests skipped\n");
1071
1072
1073 /* *** Test opening volumes/devices using GUID *** */
1074
1075 if (pGetVolumeNameForVolumeMountPointA)
1076 {
1077 strcpy(filename, "c:\\");
1078 filename[0] = windowsdir[0];
1079 ret = pGetVolumeNameForVolumeMountPointA( filename, Volume_1, MAX_PATH );
1080 ok(ret, "GetVolumeNameForVolumeMountPointA failed, for %s, last error=%d\n", filename, GetLastError());
1081 if (ret)
1082 {
1083 ok(strlen(Volume_1) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name <%s>\n", Volume_1);
1084
1085 /* test the result of opening a unique volume name (GUID)
1086 * with the trailing \
1087 * this should error out
1088 */
1089 strcpy(filename, Volume_1);
1090 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1091 FILE_SHARE_READ | FILE_SHARE_WRITE,
1092 NULL, OPEN_EXISTING,
1093 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL );
1094 todo_wine
1095 ok(hFile == INVALID_HANDLE_VALUE,
1096 "CreateFileA should not have opened %s, hFile %p\n",
1097 filename, hFile);
1098 todo_wine
1099 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
1100 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1101 filename, GetLastError());
1102 if (hFile != INVALID_HANDLE_VALUE)
1103 CloseHandle( hFile );
1104
1105 /* test the result of opening a unique volume name (GUID)
1106 * with the temp path string as dir
1107 * this should work
1108 */
1109 strcpy(filename, Volume_1);
1110 strcat(filename, temp_path+3);
1111 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1112 FILE_SHARE_READ | FILE_SHARE_WRITE,
1113 NULL, OPEN_EXISTING,
1114 FILE_FLAG_BACKUP_SEMANTICS, NULL );
1115 todo_wine
1116 ok(hFile != INVALID_HANDLE_VALUE,
1117 "CreateFileA should have opened %s, but got %u\n",
1118 filename, GetLastError());
1119 if (hFile != INVALID_HANDLE_VALUE)
1120 CloseHandle( hFile );
1121
1122 /* test the result of opening a unique volume name (GUID)
1123 * without the trailing \ and in device namespace
1124 * this should work
1125 */
1126 strcpy(filename, Volume_1);
1127 filename[2] = '.';
1128 filename[48] = 0;
1129 hFile = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1130 FILE_SHARE_READ | FILE_SHARE_WRITE,
1131 NULL, OPEN_EXISTING,
1132 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING, NULL );
1133 if (hFile != INVALID_HANDLE_VALUE || GetLastError() != ERROR_ACCESS_DENIED)
1134 {
1135 /* if we have adm rights to volume, then try rest of tests */
1136 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1137 filename, GetLastError());
1138 if (hFile != INVALID_HANDLE_VALUE)
1139 {
1140 /* if we opened the volume/device, try to read it. Since it */
1141 /* opened, we should be able to read it. We don't care about*/
1142 /* what the data is at this time. */
1143 len = 512;
1144 ret = ReadFile( hFile, buffer, len, &len, NULL );
1145 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1146 GetLastError(), ret, filename);
1147 if (ret)
1148 {
1149 trace("buffer is\n");
1150 dumpmem(buffer, 64);
1151 }
1152 CloseHandle( hFile );
1153 }
1154 }
1155 else
1156 skip("Do not have authority to access volumes. Tests skipped\n");
1157 }
1158 else
1159 win_skip("GetVolumeNameForVolumeMountPointA not functioning\n");
1160 }
1161 else
1162 win_skip("GetVolumeNameForVolumeMountPointA not found\n");
1163 }
1164
1165 static void test_CreateFileW(void)
1166 {
1167 HANDLE hFile;
1168 WCHAR temp_path[MAX_PATH];
1169 WCHAR filename[MAX_PATH];
1170 static const WCHAR emptyW[]={'\0'};
1171 static const WCHAR prefix[] = {'p','f','x',0};
1172 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1173 DWORD ret;
1174
1175 ret = GetTempPathW(MAX_PATH, temp_path);
1176 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1177 {
1178 win_skip("GetTempPathW is not available\n");
1179 return;
1180 }
1181 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1182 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1183
1184 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1185 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1186
1187 SetLastError(0xdeadbeef);
1188 hFile = CreateFileW(filename, GENERIC_READ, 0, NULL,
1189 CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
1190 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
1191 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1192
1193 SetLastError(0xdeadbeef);
1194 hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
1195 CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
1196 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
1197 "hFile %p, last error %u\n", hFile, GetLastError());
1198
1199 CloseHandle(hFile);
1200
1201 SetLastError(0xdeadbeef);
1202 hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
1203 OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
1204 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
1205 "hFile %p, last error %u\n", hFile, GetLastError());
1206
1207 CloseHandle(hFile);
1208
1209 ret = DeleteFileW(filename);
1210 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1211
1212 SetLastError(0xdeadbeef);
1213 hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
1214 OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
1215 ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == 0,
1216 "hFile %p, last error %u\n", hFile, GetLastError());
1217
1218 CloseHandle(hFile);
1219
1220 ret = DeleteFileW(filename);
1221 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1222
1223 if (0)
1224 {
1225 /* this crashes on NT4.0 */
1226 hFile = CreateFileW(NULL, GENERIC_READ, 0, NULL,
1227 CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
1228 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
1229 "CreateFileW(NULL) returned ret=%p error=%u\n",hFile,GetLastError());
1230 }
1231
1232 hFile = CreateFileW(emptyW, GENERIC_READ, 0, NULL,
1233 CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
1234 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
1235 "CreateFileW(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1236
1237 /* test the result of opening a nonexistent driver name */
1238 hFile = CreateFileW(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1239 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1240 ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND,
1241 "CreateFileW on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1242
1243 ret = CreateDirectoryW(filename, NULL);
1244 ok(ret == TRUE, "couldn't create temporary directory\n");
1245 hFile = CreateFileW(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
1246 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL);
1247 ok(hFile != INVALID_HANDLE_VALUE,
1248 "expected CreateFile to succeed on existing directory, error: %d\n", GetLastError());
1249 CloseHandle(hFile);
1250 ret = RemoveDirectoryW(filename);
1251 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1252 }
1253
1254 static void test_GetTempFileNameA(void)
1255 {
1256 UINT result;
1257 char out[MAX_PATH];
1258 char expected[MAX_PATH + 10];
1259 char windowsdir[MAX_PATH + 10];
1260 char windowsdrive[3];
1261
1262 result = GetWindowsDirectory(windowsdir, sizeof(windowsdir));
1263 ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1264 ok(result != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1265
1266 /* If the Windows directory is the root directory, it ends in backslash, not else. */
1267 if (strlen(windowsdir) != 3) /* As in "C:\" or "F:\" */
1268 {
1269 strcat(windowsdir, "\\");
1270 }
1271
1272 windowsdrive[0] = windowsdir[0];
1273 windowsdrive[1] = windowsdir[1];
1274 windowsdrive[2] = '\0';
1275
1276 result = GetTempFileNameA(windowsdrive, "abc", 1, out);
1277 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1278 ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
1279 "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
1280 windowsdrive[0], out);
1281
1282 result = GetTempFileNameA(windowsdir, "abc", 2, out);
1283 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1284 expected[0] = '\0';
1285 strcat(expected, windowsdir);
1286 strcat(expected, "abc2.tmp");
1287 ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
1288 out, expected);
1289 }
1290
1291 static void test_DeleteFileA( void )
1292 {
1293 BOOL ret;
1294
1295 ret = DeleteFileA(NULL);
1296 ok(!ret && (GetLastError() == ERROR_INVALID_PARAMETER ||
1297 GetLastError() == ERROR_PATH_NOT_FOUND),
1298 "DeleteFileA(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1299
1300 ret = DeleteFileA("");
1301 ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND ||
1302 GetLastError() == ERROR_BAD_PATHNAME),
1303 "DeleteFileA(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1304
1305 ret = DeleteFileA("nul");
1306 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
1307 GetLastError() == ERROR_INVALID_PARAMETER ||
1308 GetLastError() == ERROR_ACCESS_DENIED ||
1309 GetLastError() == ERROR_INVALID_FUNCTION),
1310 "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret,GetLastError());
1311 }
1312
1313 static void test_DeleteFileW( void )
1314 {
1315 BOOL ret;
1316 WCHAR pathW[MAX_PATH];
1317 WCHAR pathsubW[MAX_PATH];
1318 static const WCHAR dirW[] = {'d','e','l','e','t','e','f','i','l','e',0};
1319 static const WCHAR subdirW[] = {'\\','s','u','b',0};
1320 static const WCHAR emptyW[]={'\0'};
1321
1322 ret = DeleteFileW(NULL);
1323 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1324 {
1325 win_skip("DeleteFileW is not available\n");
1326 return;
1327 }
1328 ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
1329 "DeleteFileW(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1330
1331 ret = DeleteFileW(emptyW);
1332 ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
1333 "DeleteFileW(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1334
1335 /* test DeleteFile on empty directory */
1336 ret = GetTempPathW(MAX_PATH, pathW);
1337 if (ret + sizeof(dirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
1338 {
1339 ok(0, "MAX_PATH exceeded in constructing paths\n");
1340 return;
1341 }
1342 lstrcatW(pathW, dirW);
1343 lstrcpyW(pathsubW, pathW);
1344 lstrcatW(pathsubW, subdirW);
1345 ret = CreateDirectoryW(pathW, NULL);
1346 ok(ret == TRUE, "couldn't create directory deletefile\n");
1347 ret = DeleteFileW(pathW);
1348 ok(ret == FALSE, "DeleteFile should fail for empty directories\n");
1349 ret = RemoveDirectoryW(pathW);
1350 ok(ret == TRUE, "expected to remove directory deletefile\n");
1351
1352 /* test DeleteFile on non-empty directory */
1353 ret = CreateDirectoryW(pathW, NULL);
1354 ok(ret == TRUE, "couldn't create directory deletefile\n");
1355 ret = CreateDirectoryW(pathsubW, NULL);
1356 ok(ret == TRUE, "couldn't create directory deletefile\\sub\n");
1357 ret = DeleteFileW(pathW);
1358 ok(ret == FALSE, "DeleteFile should fail for non-empty directories\n");
1359 ret = RemoveDirectoryW(pathsubW);
1360 ok(ret == TRUE, "expected to remove directory deletefile\\sub\n");
1361 ret = RemoveDirectoryW(pathW);
1362 ok(ret == TRUE, "expected to remove directory deletefile\n");
1363 }
1364
1365 #define IsDotDir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
1366
1367 static void test_MoveFileA(void)
1368 {
1369 char tempdir[MAX_PATH];
1370 char source[MAX_PATH], dest[MAX_PATH];
1371 static const char prefix[] = "pfx";
1372 HANDLE hfile;
1373 HANDLE hmapfile;
1374 DWORD ret;
1375 BOOL retok;
1376
1377 ret = GetTempPathA(MAX_PATH, tempdir);
1378 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1379 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1380
1381 ret = GetTempFileNameA(tempdir, prefix, 0, source);
1382 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1383
1384 ret = GetTempFileNameA(tempdir, prefix, 0, dest);
1385 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1386
1387 ret = MoveFileA(source, dest);
1388 ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
1389 "MoveFileA: unexpected error %d\n", GetLastError());
1390
1391 ret = DeleteFileA(dest);
1392 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1393
1394 hfile = CreateFileA(source, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
1395 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1396
1397 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
1398 ok( retok && ret == sizeof(prefix),
1399 "WriteFile error %d\n", GetLastError());
1400
1401 hmapfile = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1402 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1403
1404 ret = MoveFileA(source, dest);
1405 todo_wine {
1406 ok(!ret, "MoveFileA: expected failure\n");
1407 ok(GetLastError() == ERROR_SHARING_VIOLATION ||
1408 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1409 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1410 }
1411
1412 CloseHandle(hmapfile);
1413 CloseHandle(hfile);
1414
1415 /* if MoveFile succeeded, move back to dest */
1416 if (ret) MoveFile(dest, source);
1417
1418 hfile = CreateFileA(source, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
1419 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1420
1421 hmapfile = CreateFileMapping(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1422 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1423
1424 ret = MoveFileA(source, dest);
1425 todo_wine {
1426 ok(!ret, "MoveFileA: expected failure\n");
1427 ok(GetLastError() == ERROR_SHARING_VIOLATION ||
1428 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1429 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1430 }
1431
1432 CloseHandle(hmapfile);
1433 CloseHandle(hfile);
1434
1435 /* if MoveFile succeeded, move back to dest */
1436 if (ret) MoveFile(dest, source);
1437
1438 ret = MoveFileA(source, dest);
1439 ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
1440
1441 lstrcatA(tempdir, "Remove Me");
1442 ret = CreateDirectoryA(tempdir, NULL);
1443 ok(ret == TRUE, "CreateDirectoryA failed\n");
1444
1445 lstrcpyA(source, dest);
1446 lstrcpyA(dest, tempdir);
1447 lstrcatA(dest, "\\wild?.*");
1448 /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
1449 ret = MoveFileA(source, dest);
1450 ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
1451 ok(GetLastError() == ERROR_INVALID_NAME || /* NT */
1452 GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x */
1453 "MoveFileA: with wildcards, unexpected error %d\n", GetLastError());
1454 if (ret || (GetLastError() != ERROR_INVALID_NAME))
1455 {
1456 WIN32_FIND_DATAA fd;
1457 char temppath[MAX_PATH];
1458 HANDLE hFind;
1459
1460 lstrcpyA(temppath, tempdir);
1461 lstrcatA(temppath, "\\*.*");
1462 hFind = FindFirstFileA(temppath, &fd);
1463 if (INVALID_HANDLE_VALUE != hFind)
1464 {
1465 LPSTR lpName;
1466 do
1467 {
1468 lpName = fd.cAlternateFileName;
1469 if (!lpName[0])
1470 lpName = fd.cFileName;
1471 ok(IsDotDir(lpName), "MoveFileA: wildcards file created!\n");
1472 }
1473 while (FindNextFileA(hFind, &fd));
1474 FindClose(hFind);
1475 }
1476 }
1477 ret = DeleteFileA(source);
1478 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1479 ret = DeleteFileA(dest);
1480 ok(!ret, "DeleteFileA: error %d\n", GetLastError());
1481 ret = RemoveDirectoryA(tempdir);
1482 ok(ret, "DeleteDirectoryA: error %d\n", GetLastError());
1483 }
1484
1485 static void test_MoveFileW(void)
1486 {
1487 WCHAR temp_path[MAX_PATH];
1488 WCHAR source[MAX_PATH], dest[MAX_PATH];
1489 static const WCHAR prefix[] = {'p','f','x',0};
1490 DWORD ret;
1491
1492 ret = GetTempPathW(MAX_PATH, temp_path);
1493 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1494 {
1495 win_skip("GetTempPathW is not available\n");
1496 return;
1497 }
1498 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1499 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1500
1501 ret = GetTempFileNameW(temp_path, prefix, 0, source);
1502 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1503
1504 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
1505 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1506
1507 ret = MoveFileW(source, dest);
1508 ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
1509 "CopyFileW: unexpected error %d\n", GetLastError());
1510
1511 ret = DeleteFileW(source);
1512 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1513 ret = DeleteFileW(dest);
1514 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1515 }
1516
1517 #define PATTERN_OFFSET 0x10
1518
1519 static void test_offset_in_overlapped_structure(void)
1520 {
1521 HANDLE hFile;
1522 OVERLAPPED ov;
1523 DWORD done, offset;
1524 BOOL rc;
1525 BYTE buf[256], pattern[] = "TeSt";
1526 UINT i;
1527 char temp_path[MAX_PATH], temp_fname[MAX_PATH];
1528 BOOL ret;
1529
1530 ret =GetTempPathA(MAX_PATH, temp_path);
1531 ok( ret, "GetTempPathA error %d\n", GetLastError());
1532 ret =GetTempFileNameA(temp_path, "pfx", 0, temp_fname);
1533 ok( ret, "GetTempFileNameA error %d\n", GetLastError());
1534
1535 /*** Write File *****************************************************/
1536
1537 hFile = CreateFileA(temp_fname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
1538 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
1539
1540 for(i = 0; i < sizeof(buf); i++) buf[i] = i;
1541 ret = WriteFile(hFile, buf, sizeof(buf), &done, NULL);
1542 ok( ret, "WriteFile error %d\n", GetLastError());
1543 ok(done == sizeof(buf), "expected number of bytes written %u\n", done);
1544
1545 memset(&ov, 0, sizeof(ov));
1546 S(U(ov)).Offset = PATTERN_OFFSET;
1547 S(U(ov)).OffsetHigh = 0;
1548 rc=WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
1549 /* Win 9x does not support the overlapped I/O on files */
1550 if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
1551 ok(rc, "WriteFile error %d\n", GetLastError());
1552 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
1553 offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
1554 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
1555
1556 S(U(ov)).Offset = sizeof(buf) * 2;
1557 S(U(ov)).OffsetHigh = 0;
1558 ret = WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
1559 ok( ret, "WriteFile error %d\n", GetLastError());
1560 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
1561 offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
1562 ok(offset == sizeof(buf) * 2 + sizeof(pattern), "wrong file offset %d\n", offset);
1563 }
1564
1565 CloseHandle(hFile);
1566
1567 /*** Read File *****************************************************/
1568
1569 hFile = CreateFileA(temp_fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
1570 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
1571
1572 memset(buf, 0, sizeof(buf));
1573 memset(&ov, 0, sizeof(ov));
1574 S(U(ov)).Offset = PATTERN_OFFSET;
1575 S(U(ov)).OffsetHigh = 0;
1576 rc=ReadFile(hFile, buf, sizeof(pattern), &done, &ov);
1577 /* Win 9x does not support the overlapped I/O on files */
1578 if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
1579 ok(rc, "ReadFile error %d\n", GetLastError());
1580 ok(done == sizeof(pattern), "expected number of bytes read %u\n", done);
1581 offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
1582 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
1583 ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
1584 }
1585
1586 CloseHandle(hFile);
1587
1588 ret = DeleteFileA(temp_fname);
1589 ok( ret, "DeleteFileA error %d\n", GetLastError());
1590 }
1591
1592 static void test_LockFile(void)
1593 {
1594 HANDLE handle, handle2;
1595 DWORD written;
1596 OVERLAPPED overlapped;
1597 int limited_LockFile;
1598 int limited_UnLockFile;
1599 BOOL ret;
1600
1601 handle = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1602 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1603 CREATE_ALWAYS, 0, 0 );
1604 if (handle == INVALID_HANDLE_VALUE)
1605 {
1606 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1607 return;
1608 }
1609 handle2 = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1610 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1611 OPEN_EXISTING, 0, 0 );
1612 if (handle2 == INVALID_HANDLE_VALUE)
1613 {
1614 ok( 0, "couldn't open file \"%s\" (err=%d)\n", filename, GetLastError() );
1615 goto cleanup;
1616 }
1617 ok( WriteFile( handle, sillytext, strlen(sillytext), &written, NULL ), "write failed\n" );
1618
1619 ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
1620 ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
1621
1622 limited_UnLockFile = 0;
1623 if (UnlockFile( handle, 0, 0, 0, 0 ))
1624 {
1625 limited_UnLockFile = 1;
1626 }
1627
1628 ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
1629 /* overlapping locks must fail */
1630 ok( !LockFile( handle, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
1631 ok( !LockFile( handle, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
1632 /* non-overlapping locks must succeed */
1633 ok( LockFile( handle, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
1634
1635 ok( !UnlockFile( handle, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
1636 ok( UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
1637 ok( !UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
1638 ok( UnlockFile( handle, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
1639
1640 S(U(overlapped)).Offset = 100;
1641 S(U(overlapped)).OffsetHigh = 0;
1642 overlapped.hEvent = 0;
1643
1644 /* Test for broken LockFileEx a la Windows 95 OSR2. */
1645 if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
1646 {
1647 /* LockFileEx is probably OK, test it more. */
1648 ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
1649 "LockFileEx 100,100 failed\n" );
1650 }
1651
1652 /* overlapping shared locks are OK */
1653 S(U(overlapped)).Offset = 150;
1654 limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
1655
1656 /* but exclusive is not */
1657 ok( !LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
1658 0, 50, 0, &overlapped ),
1659 "LockFileEx exclusive 150,50 succeeded\n" );
1660 if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
1661 { /* UnLockFile is capable. */
1662 S(U(overlapped)).Offset = 100;
1663 ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
1664 "UnlockFileEx 150,100 again succeeded\n" );
1665 }
1666
1667 /* shared lock can overlap exclusive if handles are equal */
1668 S(U(overlapped)).Offset = 300;
1669 ok( LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0, &overlapped ),
1670 "LockFileEx exclusive 300,100 failed\n" );
1671 ok( !LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
1672 "LockFileEx handle2 300,100 succeeded\n" );
1673 ret = LockFileEx( handle, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped );
1674 ok( ret, "LockFileEx 300,100 failed\n" );
1675 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
1676 /* exclusive lock is removed first */
1677 ok( LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
1678 "LockFileEx handle2 300,100 failed\n" );
1679 ok( UnlockFileEx( handle2, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
1680 if (ret)
1681 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
1682
1683 ret = LockFile( handle, 0, 0x10000000, 0, 0xf0000000 );
1684 if (ret)
1685 {
1686 ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
1687 ok( !LockFile( handle, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
1688 ok( UnlockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
1689 }
1690 else /* win9x */
1691 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong LockFile error %u\n", GetLastError() );
1692
1693 /* wrap-around lock should not do anything */
1694 /* (but still succeeds on NT4 so we don't check result) */
1695 LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
1696
1697 limited_LockFile = 0;
1698 if (!LockFile( handle, ~0, ~0, 1, 0 ))
1699 {
1700 limited_LockFile = 1;
1701 }
1702
1703 limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
1704
1705 /* zero-byte lock */
1706 ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
1707 if (!limited_LockFile) ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
1708 ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
1709 if (!limited_LockFile) ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
1710
1711 ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
1712 ok( !UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 succeeded\n" );
1713
1714 ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
1715
1716 CloseHandle( handle2 );
1717 cleanup:
1718 CloseHandle( handle );
1719 DeleteFileA( filename );
1720 }
1721
1722 static BOOL create_fake_dll( LPCSTR filename )
1723 {
1724 IMAGE_DOS_HEADER *dos;
1725 IMAGE_NT_HEADERS *nt;
1726 IMAGE_SECTION_HEADER *sec;
1727 BYTE *buffer;
1728 DWORD lfanew = sizeof(*dos);
1729 DWORD size = lfanew + sizeof(*nt) + sizeof(*sec);
1730 DWORD written;
1731 BOOL ret;
1732
1733 HANDLE file = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1734 if (file == INVALID_HANDLE_VALUE) return FALSE;
1735
1736 buffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
1737
1738 dos = (IMAGE_DOS_HEADER *)buffer;
1739 dos->e_magic = IMAGE_DOS_SIGNATURE;
1740 dos->e_cblp = sizeof(*dos);
1741 dos->e_cp = 1;
1742 dos->e_cparhdr = lfanew / 16;
1743 dos->e_minalloc = 0;
1744 dos->e_maxalloc = 0xffff;
1745 dos->e_ss = 0x0000;
1746 dos->e_sp = 0x00b8;
1747 dos->e_lfarlc = lfanew;
1748 dos->e_lfanew = lfanew;
1749
1750 nt = (IMAGE_NT_HEADERS *)(buffer + lfanew);
1751 nt->Signature = IMAGE_NT_SIGNATURE;
1752 #if defined __i386__
1753 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_I386;
1754 #elif defined __x86_64__
1755 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_AMD64;
1756 #elif defined __powerpc__
1757 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_POWERPC;
1758 #elif defined __sparc__
1759 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_SPARC;
1760 #elif defined __arm__
1761 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_ARM;
1762 #else
1763 # error You must specify the machine type
1764 #endif
1765 nt->FileHeader.NumberOfSections = 1;
1766 nt->FileHeader.SizeOfOptionalHeader = IMAGE_SIZEOF_NT_OPTIONAL_HEADER;
1767 nt->FileHeader.Characteristics = IMAGE_FILE_DLL | IMAGE_FILE_EXECUTABLE_IMAGE;
1768 nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
1769 nt->OptionalHeader.MajorLinkerVersion = 1;
1770 nt->OptionalHeader.MinorLinkerVersion = 0;
1771 nt->OptionalHeader.ImageBase = 0x10000000;
1772 nt->OptionalHeader.SectionAlignment = 0x1000;
1773 nt->OptionalHeader.FileAlignment = 0x1000;
1774 nt->OptionalHeader.MajorOperatingSystemVersion = 1;
1775 nt->OptionalHeader.MinorOperatingSystemVersion = 0;
1776 nt->OptionalHeader.MajorImageVersion = 1;
1777 nt->OptionalHeader.MinorImageVersion = 0;
1778 nt->OptionalHeader.MajorSubsystemVersion = 4;
1779 nt->OptionalHeader.MinorSubsystemVersion = 0;
1780 nt->OptionalHeader.SizeOfImage = 0x2000;
1781 nt->OptionalHeader.SizeOfHeaders = size;
1782 nt->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_GUI;
1783 nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
1784
1785 sec = (IMAGE_SECTION_HEADER *)(nt + 1);
1786 memcpy( sec->Name, ".rodata", sizeof(".rodata") );
1787 sec->Misc.VirtualSize = 0x1000;
1788 sec->VirtualAddress = 0x1000;
1789 sec->SizeOfRawData = 0;
1790 sec->PointerToRawData = 0;
1791 sec->Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
1792
1793 ret = WriteFile( file, buffer, size, &written, NULL ) && written == size;
1794 HeapFree( GetProcessHeap(), 0, buffer );
1795 CloseHandle( file );
1796 return ret;
1797 }
1798
1799 static unsigned int map_file_access( unsigned int access )
1800 {
1801 if (access & GENERIC_READ) access |= FILE_GENERIC_READ;
1802 if (access & GENERIC_WRITE) access |= FILE_GENERIC_WRITE;
1803 if (access & GENERIC_EXECUTE) access |= FILE_GENERIC_EXECUTE;
1804 if (access & GENERIC_ALL) access |= FILE_ALL_ACCESS;
1805 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
1806 }
1807
1808 static int is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2 )
1809 {
1810 access1 = map_file_access( access1 );
1811 access2 = map_file_access( access2 );
1812 access1 &= FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_EXECUTE | DELETE;
1813 access2 &= FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_EXECUTE | DELETE;
1814
1815 if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1816 if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1817
1818 if ((access1 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing2 & FILE_SHARE_READ)) return 0;
1819 if ((access1 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing2 & FILE_SHARE_WRITE)) return 0;
1820 if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return 0;
1821 if ((access2 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing1 & FILE_SHARE_READ)) return 0;
1822 if ((access2 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing1 & FILE_SHARE_WRITE)) return 0;
1823 if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return 0;
1824 return 1;
1825 }
1826
1827 static int is_sharing_map_compatible( DWORD map_access, DWORD access2, DWORD sharing2 )
1828 {
1829 if ((map_access == PAGE_READWRITE || map_access == PAGE_EXECUTE_READWRITE) &&
1830 !(sharing2 & FILE_SHARE_WRITE)) return 0;
1831 access2 = map_file_access( access2 );
1832 if ((map_access & SEC_IMAGE) && (access2 & FILE_WRITE_DATA)) return 0;
1833 return 1;
1834 }
1835
1836 static void test_file_sharing(void)
1837 {
1838 static const DWORD access_modes[] =
1839 { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ|GENERIC_WRITE,
1840 DELETE, GENERIC_READ|DELETE, GENERIC_WRITE|DELETE, GENERIC_READ|GENERIC_WRITE|DELETE,
1841 GENERIC_EXECUTE, GENERIC_EXECUTE | DELETE,
1842 FILE_READ_DATA, FILE_WRITE_DATA, FILE_APPEND_DATA, FILE_READ_EA, FILE_WRITE_EA,
1843 FILE_READ_DATA | FILE_EXECUTE, FILE_WRITE_DATA | FILE_EXECUTE, FILE_APPEND_DATA | FILE_EXECUTE,
1844 FILE_READ_EA | FILE_EXECUTE, FILE_WRITE_EA | FILE_EXECUTE, FILE_EXECUTE,
1845 FILE_DELETE_CHILD, FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES };
1846 static const DWORD sharing_modes[] =
1847 { 0, FILE_SHARE_READ,
1848 FILE_SHARE_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1849 FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_DELETE,
1850 FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE };
1851 static const DWORD mapping_modes[] =
1852 { PAGE_READONLY, PAGE_WRITECOPY, PAGE_READWRITE, SEC_IMAGE | PAGE_WRITECOPY };
1853 int a1, s1, a2, s2;
1854 int ret;
1855 HANDLE h, h2;
1856
1857 /* make sure the file exists */
1858 if (!create_fake_dll( filename ))
1859 {
1860 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
1861 return;
1862 }
1863
1864 for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
1865 {
1866 for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
1867 {
1868 SetLastError(0xdeadbeef);
1869 h = CreateFileA( filename, access_modes[a1], sharing_modes[s1],
1870 NULL, OPEN_EXISTING, 0, 0 );
1871 if (h == INVALID_HANDLE_VALUE)
1872 {
1873 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1874 return;
1875 }
1876 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1877 {
1878 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1879 {
1880 SetLastError(0xdeadbeef);
1881 h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1882 NULL, OPEN_EXISTING, 0, 0 );
1883 ret = GetLastError();
1884 if (is_sharing_compatible( access_modes[a1], sharing_modes[s1],
1885 access_modes[a2], sharing_modes[s2] ))
1886 {
1887 ok( h2 != INVALID_HANDLE_VALUE,
1888 "open failed for modes %x/%x/%x/%x\n",
1889 access_modes[a1], sharing_modes[s1],
1890 access_modes[a2], sharing_modes[s2] );
1891 ok( ret == 0, "wrong error code %d\n", ret );
1892 }
1893 else
1894 {
1895 ok( h2 == INVALID_HANDLE_VALUE,
1896 "open succeeded for modes %x/%x/%x/%x\n",
1897 access_modes[a1], sharing_modes[s1],
1898 access_modes[a2], sharing_modes[s2] );
1899 ok( ret == ERROR_SHARING_VIOLATION,
1900 "wrong error code %d\n", ret );
1901 }
1902 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1903 }
1904 }
1905 CloseHandle( h );
1906 }
1907 }
1908
1909 for (a1 = 0; a1 < sizeof(mapping_modes)/sizeof(mapping_modes[0]); a1++)
1910 {
1911 HANDLE m;
1912
1913 create_fake_dll( filename );
1914 SetLastError(0xdeadbeef);
1915 h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
1916 if (h == INVALID_HANDLE_VALUE)
1917 {
1918 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1919 return;
1920 }
1921 m = CreateFileMappingA( h, NULL, mapping_modes[a1], 0, 0, NULL );
1922 ok( m != 0, "failed to create mapping %x err %u\n", mapping_modes[a1], GetLastError() );
1923 CloseHandle( h );
1924 if (!m) continue;
1925
1926 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1927 {
1928 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1929 {
1930 SetLastError(0xdeadbeef);
1931 h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1932 NULL, OPEN_EXISTING, 0, 0 );
1933
1934 ret = GetLastError();
1935 if (h2 == INVALID_HANDLE_VALUE)
1936 {
1937 ok( !is_sharing_map_compatible(mapping_modes[a1], access_modes[a2], sharing_modes[s2]),
1938 "open failed for modes map %x/%x/%x\n",
1939 mapping_modes[a1], access_modes[a2], sharing_modes[s2] );
1940 ok( ret == ERROR_SHARING_VIOLATION,
1941 "wrong error code %d\n", ret );
1942 }
1943 else
1944 {
1945 if (!is_sharing_map_compatible(mapping_modes[a1], access_modes[a2], sharing_modes[s2]))
1946 ok( broken(1), /* no checking on nt4 */
1947 "open succeeded for modes map %x/%x/%x\n",
1948 mapping_modes[a1], access_modes[a2], sharing_modes[s2] );
1949 ok( ret == 0xdeadbeef /* Win9x */ ||
1950 ret == 0, /* XP */
1951 "wrong error code %d\n", ret );
1952 CloseHandle( h2 );
1953 }
1954 }
1955 }
1956
1957 /* try CREATE_ALWAYS over an existing mapping */
1958 SetLastError(0xdeadbeef);
1959 h2 = CreateFileA( filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
1960 NULL, CREATE_ALWAYS, 0, 0 );
1961 ret = GetLastError();
1962 if (mapping_modes[a1] & SEC_IMAGE)
1963 {
1964 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1965 ok( ret == ERROR_SHARING_VIOLATION, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1966 }
1967 else
1968 {
1969 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1970 ok( ret == ERROR_USER_MAPPED_FILE, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1971 }
1972 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1973
1974 /* try DELETE_ON_CLOSE over an existing mapping */
1975 SetLastError(0xdeadbeef);
1976 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
1977 NULL, OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, 0 );
1978 ret = GetLastError();
1979 if (mapping_modes[a1] & SEC_IMAGE)
1980 {
1981 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1982 ok( ret == ERROR_ACCESS_DENIED, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1983 }
1984 else
1985 {
1986 ok( h2 != INVALID_HANDLE_VALUE, "open failed for map %x err %u\n", mapping_modes[a1], ret );
1987 }
1988 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1989
1990 CloseHandle( m );
1991 }
1992
1993 SetLastError(0xdeadbeef);
1994 h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, 0 );
1995 ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
1996
1997 SetLastError(0xdeadbeef);
1998 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1999 ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
2000 ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %d\n", GetLastError() );
2001
2002 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
2003 ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
2004
2005 CloseHandle(h);
2006 CloseHandle(h2);
2007
2008 DeleteFileA( filename );
2009 }
2010
2011 static char get_windows_drive(void)
2012 {
2013 char windowsdir[MAX_PATH];
2014 GetWindowsDirectory(windowsdir, sizeof(windowsdir));
2015 return windowsdir[0];
2016 }
2017
2018 static void test_FindFirstFileA(void)
2019 {
2020 HANDLE handle;
2021 WIN32_FIND_DATAA data;
2022 int err;
2023 char buffer[5] = "C:\\";
2024 char buffer2[100];
2025 char nonexistent[MAX_PATH];
2026
2027 /* try FindFirstFileA on "C:\" */
2028 buffer[0] = get_windows_drive();
2029
2030 SetLastError( 0xdeadbeaf );
2031 handle = FindFirstFileA(buffer, &data);
2032 err = GetLastError();
2033 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on root directory should fail\n" );
2034 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2035
2036 /* try FindFirstFileA on "C:\*" */
2037 strcpy(buffer2, buffer);
2038 strcat(buffer2, "*");
2039 handle = FindFirstFileA(buffer2, &data);
2040 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2041 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2042 "FindFirstFile shouldn't return '%s' in drive root\n", data.cFileName );
2043 if (FindNextFileA( handle, &data ))
2044 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2045 "FindNextFile shouldn't return '%s' in drive root\n", data.cFileName );
2046 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2047
2048 /* try FindFirstFileA on windows dir */
2049 GetWindowsDirectory( buffer2, sizeof(buffer2) );
2050 strcat(buffer2, "\\*");
2051 handle = FindFirstFileA(buffer2, &data);
2052 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2053 ok( !strcmp( data.cFileName, "." ), "FindFirstFile should return '.' first\n" );
2054 ok( FindNextFileA( handle, &data ), "FindNextFile failed\n" );
2055 ok( !strcmp( data.cFileName, ".." ), "FindNextFile should return '..' as second entry\n" );
2056 while (FindNextFileA( handle, &data ))
2057 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2058 "FindNextFile shouldn't return '%s'\n", data.cFileName );
2059 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2060
2061 /* try FindFirstFileA on "C:\foo\" */
2062 SetLastError( 0xdeadbeaf );
2063 if (!GetTempFileNameA( buffer, "foo", 0, nonexistent ) && GetLastError() == ERROR_ACCESS_DENIED)
2064 {
2065 char tmp[MAX_PATH];
2066 GetTempPathA( sizeof(tmp), tmp );
2067 GetTempFileNameA( tmp, "foo", 0, nonexistent );
2068 }
2069 DeleteFileA( nonexistent );
2070 strcpy(buffer2, nonexistent);
2071 strcat(buffer2, "\\");
2072 handle = FindFirstFileA(buffer2, &data);
2073 err = GetLastError();
2074 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2075 todo_wine {
2076 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2077 }
2078
2079 /* try FindFirstFileA on "C:\foo\bar.txt" */
2080 SetLastError( 0xdeadbeaf );
2081 strcpy(buffer2, nonexistent);
2082 strcat(buffer2, "\\bar.txt");
2083 handle = FindFirstFileA(buffer2, &data);
2084 err = GetLastError();
2085 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2086 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2087
2088 /* try FindFirstFileA on "C:\foo\*.*" */
2089 SetLastError( 0xdeadbeaf );
2090 strcpy(buffer2, nonexistent);
2091 strcat(buffer2, "\\*.*");
2092 handle = FindFirstFileA(buffer2, &data);
2093 err = GetLastError();
2094 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2095 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2096
2097 /* try FindFirstFileA on "foo\bar.txt" */
2098 SetLastError( 0xdeadbeaf );
2099 strcpy(buffer2, nonexistent + 3);
2100 strcat(buffer2, "\\bar.txt");
2101 handle = FindFirstFileA(buffer2, &data);
2102 err = GetLastError();
2103 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2104 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2105
2106 /* try FindFirstFileA on "c:\nul" */
2107 SetLastError( 0xdeadbeaf );
2108 strcpy(buffer2, buffer);
2109 strcat(buffer2, "nul");
2110 handle = FindFirstFileA(buffer2, &data);
2111 err = GetLastError();
2112 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2113 ok( 0 == lstrcmpiA(data.cFileName, "nul"), "wrong name %s\n", data.cFileName );
2114 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2115 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2116 "wrong attributes %x\n", data.dwFileAttributes );
2117 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2118 {
2119 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2120 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2121 }
2122 SetLastError( 0xdeadbeaf );
2123 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2124 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2125 ok( FindClose( handle ), "failed to close handle\n" );
2126
2127 /* try FindFirstFileA on "lpt1" */
2128 SetLastError( 0xdeadbeaf );
2129 strcpy(buffer2, "lpt1");
2130 handle = FindFirstFileA(buffer2, &data);
2131 err = GetLastError();
2132 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2133 ok( 0 == lstrcmpiA(data.cFileName, "lpt1"), "wrong name %s\n", data.cFileName );
2134 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2135 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2136 "wrong attributes %x\n", data.dwFileAttributes );
2137 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2138 {
2139 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2140 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2141 }
2142 SetLastError( 0xdeadbeaf );
2143 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2144 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2145 ok( FindClose( handle ), "failed to close handle\n" );
2146
2147 /* try FindFirstFileA on "c:\nul\*" */
2148 SetLastError( 0xdeadbeaf );
2149 strcpy(buffer2, buffer);
2150 strcat(buffer2, "nul\\*");
2151 handle = FindFirstFileA(buffer2, &data);
2152 err = GetLastError();
2153 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2154 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2155
2156 /* try FindFirstFileA on "c:\nul*" */
2157 SetLastError( 0xdeadbeaf );
2158 strcpy(buffer2, buffer);
2159 strcat(buffer2, "nul*");
2160 handle = FindFirstFileA(buffer2, &data);
2161 err = GetLastError();
2162 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2163 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2164
2165 /* try FindFirstFileA on "c:\foo\bar\nul" */
2166 SetLastError( 0xdeadbeaf );
2167 strcpy(buffer2, buffer);
2168 strcat(buffer2, "foo\\bar\\nul");
2169 handle = FindFirstFileA(buffer2, &data);
2170 err = GetLastError();
2171 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2172 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2173
2174 /* try FindFirstFileA on "c:\foo\nul\bar" */
2175 SetLastError( 0xdeadbeaf );
2176 strcpy(buffer2, buffer);
2177 strcat(buffer2, "foo\\nul\\bar");
2178 handle = FindFirstFileA(buffer2, &data);
2179 err = GetLastError();
2180 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2181 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2182 }
2183
2184 static void test_FindNextFileA(void)
2185 {
2186 HANDLE handle;
2187 WIN32_FIND_DATAA search_results;
2188 int err;
2189 char buffer[5] = "C:\\*";
2190
2191 buffer[0] = get_windows_drive();
2192 handle = FindFirstFileA(buffer,&search_results);
2193 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
2194 while (FindNextFile(handle, &search_results))
2195 {
2196 /* get to the end of the files */
2197 }
2198 ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
2199 err = GetLastError();
2200 ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
2201 }
2202
2203 static void test_FindFirstFileExA(FINDEX_SEARCH_OPS search_ops)
2204 {
2205 WIN32_FIND_DATAA search_results;
2206 HANDLE handle;
2207 BOOL ret;
2208
2209 if (!pFindFirstFileExA)
2210 {
2211 win_skip("FindFirstFileExA() is missing\n");
2212 return;
2213 }
2214
2215 CreateDirectoryA("test-dir", NULL);
2216 _lclose(_lcreat("test-dir\\file1", 0));
2217 _lclose(_lcreat("test-dir\\file2", 0));
2218 CreateDirectoryA("test-dir\\dir1", NULL);
2219 SetLastError(0xdeadbeef);
2220 handle = pFindFirstFileExA("test-dir\\*", FindExInfoStandard, &search_results, search_ops, NULL, 0);
2221 if (handle == INVALID_HANDLE_VALUE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2222 {
2223 win_skip("FindFirstFileExA is not implemented\n");
2224 goto cleanup;
2225 }
2226 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFile failed (err=%u)\n", GetLastError());
2227 ok(strcmp(search_results.cFileName, ".") == 0, "First entry should be '.', is %s\n", search_results.cFileName);
2228
2229 #define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
2230
2231 ok(FindNextFile(handle, &search_results), "Fetching second file failed\n");
2232 ok(strcmp(search_results.cFileName, "..") == 0, "Second entry should be '..' is %s\n", search_results.cFileName);
2233
2234 ok(FindNextFile(handle, &search_results), "Fetching third file failed\n");
2235 ok(CHECK_NAME(search_results.cFileName), "Invalid third entry - %s\n", search_results.cFileName);
2236
2237 SetLastError(0xdeadbeef);
2238 ret = FindNextFile(handle, &search_results);
2239 if (!ret && (GetLastError() == ERROR_NO_MORE_FILES) && (search_ops == FindExSearchLimitToDirectories))
2240 {
2241 skip("File system supports directory filtering\n");
2242 /* Results from the previous call are not cleared */
2243 ok(strcmp(search_results.cFileName, "dir1") == 0, "Third entry should be 'dir1' is %s\n", search_results.cFileName);
2244 FindClose( handle );
2245 goto cleanup;
2246 }
2247
2248 ok(ret, "Fetching fourth file failed\n");
2249 ok(CHECK_NAME(search_results.cFileName), "Invalid fourth entry - %s\n", search_results.cFileName);
2250
2251 ok(FindNextFile(handle, &search_results), "Fetching fifth file failed\n");
2252 ok(CHECK_NAME(search_results.cFileName), "Invalid fifth entry - %s\n", search_results.cFileName);
2253
2254 #undef CHECK_NAME
2255
2256 ok(FindNextFile(handle, &search_results) == FALSE, "Fetching sixth file should fail\n");
2257
2258 FindClose( handle );
2259
2260 cleanup:
2261 DeleteFileA("test-dir\\file1");
2262 DeleteFileA("test-dir\\file2");
2263 RemoveDirectoryA("test-dir\\dir1");
2264 RemoveDirectoryA("test-dir");
2265 }
2266
2267 static int test_Mapfile_createtemp(HANDLE *handle)
2268 {
2269 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL);
2270 DeleteFile(filename);
2271 *handle = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 0,
2272 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2273 if (*handle != INVALID_HANDLE_VALUE) {
2274
2275 return 1;
2276 }
2277
2278 return 0;
2279 }
2280
2281 static void test_MapFile(void)
2282 {
2283 HANDLE handle;
2284 HANDLE hmap;
2285
2286 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
2287
2288 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
2289 ok( hmap != NULL, "mapping should work, I named it!\n" );
2290
2291 ok( CloseHandle( hmap ), "can't close mapping handle\n");
2292
2293 /* We have to close file before we try new stuff with mapping again.
2294 Else we would always succeed on XP or block descriptors on 95. */
2295 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
2296 ok( hmap != NULL, "We should still be able to map!\n" );
2297 ok( CloseHandle( hmap ), "can't close mapping handle\n");
2298 ok( CloseHandle( handle ), "can't close file handle\n");
2299 handle = NULL;
2300
2301 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
2302
2303 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
2304 ok( hmap == NULL, "mapped zero size file\n");
2305 ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
2306
2307 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0, NULL );
2308 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
2309 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2310 if ( hmap )
2311 CloseHandle( hmap );
2312
2313 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0x10000, NULL );
2314 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
2315 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2316 if ( hmap )
2317 CloseHandle( hmap );
2318
2319 /* On XP you can now map again, on Win 95 you cannot. */
2320
2321 ok( CloseHandle( handle ), "can't close file handle\n");
2322 ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
2323 }
2324
2325 static void test_GetFileType(void)
2326 {
2327 DWORD type;
2328 HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
2329 ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
2330 type = GetFileType(h);
2331 ok( type == FILE_TYPE_DISK, "expected type disk got %d\n", type );
2332 CloseHandle( h );
2333 h = CreateFileA( "nul", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2334 ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
2335 type = GetFileType(h);
2336 ok( type == FILE_TYPE_CHAR, "expected type char for nul got %d\n", type );
2337 CloseHandle( h );
2338 DeleteFileA( filename );
2339 }
2340
2341 static int completion_count;
2342
2343 static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
2344 {
2345 /* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
2346 ReleaseSemaphore(ovl->hEvent, 1, NULL);
2347 completion_count++;
2348 }
2349
2350 static void test_async_file_errors(void)
2351 {
2352 char szFile[MAX_PATH];
2353 HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
2354 HANDLE hFile;
2355 LPVOID lpBuffer = HeapAlloc(GetProcessHeap(), 0, 4096);
2356 OVERLAPPED ovl;
2357 S(U(ovl)).Offset = 0;
2358 S(U(ovl)).OffsetHigh = 0;
2359 ovl.hEvent = hSem;
2360 completion_count = 0;
2361 szFile[0] = '\0';
2362 GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
2363 strcat(szFile, "\\win.ini");
2364 hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2365 NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
2366 if (hFile == INVALID_HANDLE_VALUE) /* win9x doesn't like FILE_SHARE_DELETE */
2367 hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
2368 NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
2369 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA(%s ...) failed\n", szFile);
2370 while (TRUE)
2371 {
2372 BOOL res;
2373 DWORD count;
2374 while (WaitForSingleObjectEx(hSem, INFINITE, TRUE) == WAIT_IO_COMPLETION)
2375 ;
2376 res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
2377 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
2378 if (!res)
2379 break;
2380 if (!GetOverlappedResult(hFile, &ovl, &count, FALSE))
2381 break;
2382 S(U(ovl)).Offset += count;
2383 /* i/o completion routine only called if ReadFileEx returned success.
2384 * we only care about violations of this rule so undo what should have
2385 * been done */
2386 completion_count--;
2387 }
2388 ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
2389 /*printf("Error = %ld\n", GetLastError());*/
2390 HeapFree(GetProcessHeap(), 0, lpBuffer);
2391 }
2392
2393 static BOOL user_apc_ran;
2394 static void CALLBACK user_apc(ULONG_PTR param)
2395 {
2396 user_apc_ran = TRUE;
2397 }
2398
2399 static void test_read_write(void)
2400 {
2401 DWORD bytes, ret, old_prot;
2402 HANDLE hFile;
2403 char temp_path[MAX_PATH];
2404 char filename[MAX_PATH];
2405 char *mem;
2406 static const char prefix[] = "pfx";
2407
2408 ret = GetTempPathA(MAX_PATH, temp_path);
2409 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
2410 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
2411
2412 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
2413 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
2414
2415 hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
2416 CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
2417 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
2418
2419 user_apc_ran = FALSE;
2420 if (pQueueUserAPC) {
2421 trace("Queueing an user APC\n"); /* verify the file is non alerable */
2422 ret = pQueueUserAPC(&user_apc, GetCurrentThread(), 0);
2423 ok(ret, "QueueUserAPC failed: %d\n", GetLastError());
2424 }
2425
2426 SetLastError(12345678);
2427 bytes = 12345678;
2428 ret = WriteFile(hFile, NULL, 0, &bytes, NULL);
2429 ok(ret && GetLastError() == 12345678,
2430 "ret = %d, error %d\n", ret, GetLastError());
2431 ok(!bytes, "bytes = %d\n", bytes);
2432
2433 SetLastError(12345678);
2434 bytes = 12345678;
2435 ret = WriteFile(hFile, NULL, 10, &bytes, NULL);
2436 ok((!ret && GetLastError() == ERROR_INVALID_USER_BUFFER) || /* Win2k */
2437 (ret && GetLastError() == 12345678), /* Win9x */
2438 "ret = %d, error %d\n", ret, GetLastError());
2439 ok(!bytes || /* Win2k */
2440 bytes == 10, /* Win9x */
2441 "bytes = %d\n", bytes);
2442
2443 /* make sure the file contains data */
2444 WriteFile(hFile, "this is the test data", 21, &bytes, NULL);
2445 SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
2446
2447 SetLastError(12345678);
2448 bytes = 12345678;
2449 ret = ReadFile(hFile, NULL, 0, &bytes, NULL);
2450 ok(ret && GetLastError() == 12345678,
2451 "ret = %d, error %d\n", ret, GetLastError());
2452 ok(!bytes, "bytes = %d\n", bytes);
2453
2454 SetLastError(12345678);
2455 bytes = 12345678;
2456 ret = ReadFile(hFile, NULL, 10, &bytes, NULL);
2457 ok(!ret && (GetLastError() == ERROR_NOACCESS || /* Win2k */
2458 GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
2459 "ret = %d, error %d\n", ret, GetLastError());
2460 ok(!bytes, "bytes = %d\n", bytes);
2461
2462 ok(user_apc_ran == FALSE, "UserAPC ran, file using alertable io mode\n");
2463 if (pQueueUserAPC)
2464 SleepEx(0, TRUE); /* get rid of apc */
2465
2466 /* test passing protected memory as buffer */
2467
2468 mem = VirtualAlloc( NULL, 0x4000, MEM_COMMIT, PAGE_READWRITE );
2469 ok( mem != NULL, "failed to allocate virtual mem error %u\n", GetLastError() );
2470
2471 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2472 ok( ret, "WriteFile failed error %u\n", GetLastError() );
2473 ok( bytes == 0x4000, "only wrote %x bytes\n", bytes );
2474
2475 ret = VirtualProtect( mem + 0x2000, 0x2000, PAGE_NOACCESS, &old_prot );
2476 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2477
2478 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2479 ok( !ret, "WriteFile succeeded\n" );
2480 ok( GetLastError() == ERROR_INVALID_USER_BUFFER ||
2481 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2482 "wrong error %u\n", GetLastError() );
2483 ok( bytes == 0, "wrote %x bytes\n", bytes );
2484
2485 ret = WriteFile( (HANDLE)0xdead, mem, 0x4000, &bytes, NULL );
2486 ok( !ret, "WriteFile succeeded\n" );
2487 ok( GetLastError() == ERROR_INVALID_HANDLE || /* handle is checked before buffer on NT */
2488 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2489 "wrong error %u\n", GetLastError() );
2490 ok( bytes == 0, "wrote %x bytes\n", bytes );
2491
2492 ret = VirtualProtect( mem, 0x2000, PAGE_NOACCESS, &old_prot );
2493 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2494
2495 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2496 ok( !ret, "WriteFile succeeded\n" );
2497 ok( GetLastError() == ERROR_INVALID_USER_BUFFER ||
2498 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2499 "wrong error %u\n", GetLastError() );
2500 ok( bytes == 0, "wrote %x bytes\n", bytes );
2501
2502 SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
2503
2504 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2505 ok( !ret, "ReadFile succeeded\n" );
2506 ok( GetLastError() == ERROR_NOACCESS ||
2507 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2508 "wrong error %u\n", GetLastError() );
2509 ok( bytes == 0, "read %x bytes\n", bytes );
2510
2511 ret = VirtualProtect( mem, 0x2000, PAGE_READONLY, &old_prot );
2512 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2513
2514 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2515 ok( !ret, "ReadFile succeeded\n" );
2516 ok( GetLastError() == ERROR_NOACCESS ||
2517 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2518 "wrong error %u\n", GetLastError() );
2519 ok( bytes == 0, "read %x bytes\n", bytes );
2520
2521 ret = VirtualProtect( mem, 0x2000, PAGE_READWRITE, &old_prot );
2522 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2523
2524 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2525 ok( !ret, "ReadFile succeeded\n" );
2526 ok( GetLastError() == ERROR_NOACCESS ||
2527 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2528 "wrong error %u\n", GetLastError() );
2529 ok( bytes == 0, "read %x bytes\n", bytes );
2530
2531 SetFilePointer( hFile, 0x1234, NULL, FILE_BEGIN );
2532 SetEndOfFile( hFile );
2533 SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
2534
2535 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2536 ok( !ret, "ReadFile succeeded\n" );
2537 ok( GetLastError() == ERROR_NOACCESS ||
2538 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2539 "wrong error %u\n", GetLastError() );
2540 ok( bytes == 0, "read %x bytes\n", bytes );
2541
2542 ret = ReadFile( hFile, mem, 0x2000, &bytes, NULL );
2543 ok( ret, "ReadFile failed error %u\n", GetLastError() );
2544 ok( bytes == 0x1234, "read %x bytes\n", bytes );
2545
2546 ret = ReadFile( hFile, NULL, 1, &bytes, NULL );
2547 ok( !ret, "ReadFile succeeded\n" );
2548 ok( GetLastError() == ERROR_NOACCESS ||
2549 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2550 "wrong error %u\n", GetLastError() );
2551 ok( bytes == 0, "read %x bytes\n", bytes );
2552
2553 VirtualFree( mem, 0, MEM_FREE );
2554
2555 ret = CloseHandle(hFile);
2556 ok( ret, "CloseHandle: error %d\n", GetLastError());
2557 ret = DeleteFileA(filename);
2558 ok( ret, "DeleteFileA: error %d\n", GetLastError());
2559 }
2560
2561 static void test_OpenFile(void)
2562 {
2563 HFILE hFile;
2564 OFSTRUCT ofs;
2565 BOOL ret;
2566 DWORD retval;
2567
2568 static const char file[] = "regedit.exe";
2569 static const char foo[] = ".\\foo-bar-foo.baz";
2570 static const char *foo_too_long = ".\\foo-bar-foo.baz+++++++++++++++"
2571 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2572 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2573 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2574 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2575 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
2576 char buff[MAX_PATH];
2577 char buff_long[4*MAX_PATH];
2578 char filled_0xA5[OFS_MAXPATHNAME];
2579 char *p;
2580 UINT length;
2581
2582 /* Check for existing file */
2583 if (!pGetSystemWindowsDirectoryA)
2584 length = GetWindowsDirectoryA(buff, MAX_PATH);
2585 else
2586 length = pGetSystemWindowsDirectoryA(buff, MAX_PATH);
2587
2588 if (length + sizeof(file) < MAX_PATH)
2589 {
2590 p = buff + strlen(buff);
2591 if (p > buff && p[-1] != '\\') *p++ = '\\';
2592 strcpy( p, file );
2593 memset(&ofs, 0xA5, sizeof(ofs));
2594 SetLastError(0xfaceabee);
2595
2596 hFile = OpenFile(buff, &ofs, OF_EXIST);
2597 ok( hFile == TRUE, "%s not found : %d\n", buff, GetLastError() );
2598 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2599 "GetLastError() returns %d\n", GetLastError() );
2600 ok( ofs.cBytes == sizeof(ofs), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2601 ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2602 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2603 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2604 ofs.szPathName, buff );
2605 }
2606
2607 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
2608 length = GetCurrentDirectoryA(MAX_PATH, buff);
2609
2610 /* Check for nonexistent file */
2611 if (length + sizeof(foo) < MAX_PATH)
2612 {
2613 p = buff + strlen(buff);
2614 if (p > buff && p[-1] != '\\') *p++ = '\\';
2615 strcpy( p, foo + 2 );
2616 memset(&ofs, 0xA5, sizeof(ofs));
2617 SetLastError(0xfaceabee);
2618
2619 hFile = OpenFile(foo, &ofs, OF_EXIST);
2620 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
2621 ok( GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError() returns %d\n", GetLastError() );
2622 todo_wine
2623 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2624 ok( ofs.nErrCode == ERROR_FILE_NOT_FOUND, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2625 ok( lstrcmpiA(ofs.szPathName, buff) == 0 || strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
2626 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2627 ofs.szPathName, buff );
2628 }
2629
2630 length = GetCurrentDirectoryA(MAX_PATH, buff_long);
2631 length += lstrlenA(foo_too_long + 1);
2632
2633 /* Check for nonexistent file with too long filename */
2634 if (length >= OFS_MAXPATHNAME && length < sizeof(buff_long))
2635 {
2636 lstrcatA(buff_long, foo_too_long + 1); /* Avoid '.' during concatenation */
2637 memset(&ofs, 0xA5, sizeof(ofs));
2638 SetLastError(0xfaceabee);
2639
2640 hFile = OpenFile(foo_too_long, &ofs, OF_EXIST);
2641 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
2642 ok( GetLastError() == ERROR_INVALID_DATA || GetLastError() == ERROR_FILENAME_EXCED_RANGE,
2643 "GetLastError() returns %d\n", GetLastError() );
2644 todo_wine
2645 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2646 ok( ofs.nErrCode == ERROR_INVALID_DATA || ofs.nErrCode == ERROR_FILENAME_EXCED_RANGE,
2647 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2648 ok( strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
2649 "OpenFile returned '%s', but was expected to return string filled with 0xA5\n",
2650 ofs.szPathName );
2651 }
2652
2653 length = GetCurrentDirectoryA(MAX_PATH, buff) + sizeof(filename);
2654
2655 if (length >= MAX_PATH)
2656 {
2657 trace("Buffer too small, requested length = %d, but MAX_PATH = %d. Skipping test.\n", length, MAX_PATH);
2658 return;
2659 }
2660 p = buff + strlen(buff);
2661 if (p > buff && p[-1] != '\\') *p++ = '\\';
2662 strcpy( p, filename );
2663
2664 memset(&ofs, 0xA5, sizeof(ofs));
2665 SetLastError(0xfaceabee);
2666 /* Create an empty file */
2667 hFile = OpenFile(filename, &ofs, OF_CREATE);
2668 ok( hFile != HFILE_ERROR, "OpenFile failed to create nonexistent file\n" );
2669 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2670 "GetLastError() returns %d\n", GetLastError() );
2671 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2672 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2673 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2674 ret = _lclose(hFile);
2675 ok( !ret, "_lclose() returns %d\n", ret );
2676 retval = GetFileAttributesA(filename);
2677 ok( retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %d\n", GetLastError() );
2678
2679 memset(&ofs, 0xA5, sizeof(ofs));
2680 SetLastError(0xfaceabee);
2681 /* Check various opening options: */
2682 /* for reading only, */
2683 hFile = OpenFile(filename, &ofs, OF_READ);
2684 ok( hFile != HFILE_ERROR, "OpenFile failed on read\n" );
2685 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2686 "GetLastError() returns %d\n", GetLastError() );
2687 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2688 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2689 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2690 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2691 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2692 ret = _lclose(hFile);
2693 ok( !ret, "_lclose() returns %d\n", ret );
2694
2695 memset(&ofs, 0xA5, sizeof(ofs));
2696 SetLastError(0xfaceabee);
2697 /* for writing only, */
2698 hFile = OpenFile(filename, &ofs, OF_WRITE);
2699 ok( hFile != HFILE_ERROR, "OpenFile failed on write\n" );
2700 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2701 "GetLastError() returns %d\n", GetLastError() );
2702 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2703 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2704 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2705 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2706 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2707 ret = _lclose(hFile);
2708 ok( !ret, "_lclose() returns %d\n", ret );
2709
2710 memset(&ofs, 0xA5, sizeof(ofs));
2711 SetLastError(0xfaceabee);
2712 /* for reading and writing, */
2713 hFile = OpenFile(filename, &ofs, OF_READWRITE);
2714 ok( hFile != HFILE_ERROR, "OpenFile failed on read/write\n" );
2715 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2716 "GetLastError() returns %d\n", GetLastError() );
2717 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2718 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2719 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2720 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2721 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2722 ret = _lclose(hFile);
2723 ok( !ret, "_lclose() returns %d\n", ret );
2724
2725 memset(&ofs, 0xA5, sizeof(ofs));
2726 SetLastError(0xfaceabee);
2727 /* for checking file presence. */
2728 hFile = OpenFile(filename, &ofs, OF_EXIST);
2729 ok( hFile == 1, "OpenFile failed on finding our created file\n" );
2730 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2731 "GetLastError() returns %d\n", GetLastError() );
2732 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2733 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2734 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2735 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2736 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2737
2738 memset(&ofs, 0xA5, sizeof(ofs));
2739 SetLastError(0xfaceabee);
2740 /* Delete the file and make sure it doesn't exist anymore */
2741 hFile = OpenFile(filename, &ofs, OF_DELETE);
2742 ok( hFile == 1, "OpenFile failed on delete (%d)\n", hFile );
2743 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2744 "GetLastError() returns %d\n", GetLastError() );
2745 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2746 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2747 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2748 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2749 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2750
2751 retval = GetFileAttributesA(filename);
2752 ok( retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file\n" );
2753 }
2754
2755 static void test_overlapped(void)
2756 {
2757 OVERLAPPED ov;
2758 DWORD r, result;
2759
2760 /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
2761 if (0) /* tested: WinXP */
2762 {
2763 GetOverlappedResult(0, NULL, &result, FALSE);
2764 GetOverlappedResult(0, &ov, NULL, FALSE);
2765 GetOverlappedResult(0, NULL, NULL, FALSE);
2766 }
2767
2768 memset( &ov, 0, sizeof ov );
2769 result = 1;
2770 r = GetOverlappedResult(0, &ov, &result, 0);
2771 if (r)
2772 ok( result == 0, "wrong result %u\n", result );
2773 else /* win9x */
2774 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2775
2776 result = 0;
2777 ov.Internal = 0;
2778 ov.InternalHigh = 0xabcd;
2779 r = GetOverlappedResult(0, &ov, &result, 0);
2780 if (r)
2781 ok( result == 0xabcd, "wrong result %u\n", result );
2782 else /* win9x */
2783 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2784
2785 SetLastError( 0xb00 );
2786 result = 0;
2787 ov.Internal = STATUS_INVALID_HANDLE;
2788 ov.InternalHigh = 0xabcd;
2789 r = GetOverlappedResult(0, &ov, &result, 0);
2790 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2791 ok( r == FALSE, "should return false\n");
2792 ok( result == 0xabcd || result == 0 /* win9x */, "wrong result %u\n", result );
2793
2794 SetLastError( 0xb00 );
2795 result = 0;
2796 ov.Internal = STATUS_PENDING;
2797 ov.InternalHigh = 0xabcd;
2798 r = GetOverlappedResult(0, &ov, &result, 0);
2799 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2800 "wrong error %u\n", GetLastError() );
2801 ok( r == FALSE, "should return false\n");
2802 ok( result == 0, "wrong result %u\n", result );
2803
2804 SetLastError( 0xb00 );
2805 ov.hEvent = CreateEvent( NULL, 1, 1, NULL );
2806 ov.Internal = STATUS_PENDING;
2807 ov.InternalHigh = 0xabcd;
2808 r = GetOverlappedResult(0, &ov, &result, 0);
2809 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2810 "wrong error %u\n", GetLastError() );
2811 ok( r == FALSE, "should return false\n");
2812
2813 ResetEvent( ov.hEvent );
2814
2815 SetLastError( 0xb00 );
2816 ov.Internal = STATUS_PENDING;
2817 ov.InternalHigh = 0;
2818 r = GetOverlappedResult(0, &ov, &result, 0);
2819 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2820 "wrong error %u\n", GetLastError() );
2821 ok( r == FALSE, "should return false\n");
2822
2823 r = CloseHandle( ov.hEvent );
2824 ok( r == TRUE, "close handle failed\n");
2825 }
2826
2827 static void test_RemoveDirectory(void)
2828 {
2829 int rc;
2830 char directory[] = "removeme";
2831
2832 rc = CreateDirectory(directory, NULL);
2833 ok( rc, "Createdirectory failed, gle=%d\n", GetLastError() );
2834
2835 rc = SetCurrentDirectory(directory);
2836 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2837
2838 rc = RemoveDirectory(".");
2839 if (!rc)
2840 {
2841 rc = SetCurrentDirectory("..");
2842 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2843
2844 rc = RemoveDirectory(directory);
2845 ok( rc, "RemoveDirectory failed, gle=%d\n", GetLastError() );
2846 }
2847 }
2848
2849 static BOOL check_file_time( const FILETIME *ft1, const FILETIME *ft2, UINT tolerance )
2850 {
2851 ULONGLONG t1 = ((ULONGLONG)ft1->dwHighDateTime << 32) | ft1->dwLowDateTime;
2852 ULONGLONG t2 = ((ULONGLONG)ft2->dwHighDateTime << 32) | ft2->dwLowDateTime;
2853 return abs(t1 - t2) <= tolerance;
2854 }
2855
2856 static void test_ReplaceFileA(void)
2857 {
2858 char replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
2859 HANDLE hReplacedFile, hReplacementFile, hBackupFile;
2860 static const char replacedData[] = "file-to-replace";
2861 static const char replacementData[] = "new-file";
2862 static const char backupData[] = "backup-file";
2863 FILETIME ftReplaced, ftReplacement, ftBackup;
2864 static const char prefix[] = "pfx";
2865 char temp_path[MAX_PATH];
2866 DWORD ret;
2867 BOOL retok, removeBackup = FALSE;
2868
2869 if (!pReplaceFileA)
2870 {
2871 win_skip("ReplaceFileA() is missing\n");
2872 return;
2873 }
2874
2875 ret = GetTempPathA(MAX_PATH, temp_path);
2876 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
2877 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
2878
2879 ret = GetTempFileNameA(temp_path, prefix, 0, replaced);
2880 ok(ret != 0, "GetTempFileNameA error (replaced) %d\n", GetLastError());
2881
2882 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2883 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2884
2885 ret = GetTempFileNameA(temp_path, prefix, 0, backup);
2886 ok(ret != 0, "GetTempFileNameA error (backup) %d\n", GetLastError());
2887
2888 /* place predictable data in the file to be replaced */
2889 hReplacedFile = CreateFileA(replaced, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2890 ok(hReplacedFile != INVALID_HANDLE_VALUE,
2891 "failed to open replaced file\n");
2892 retok = WriteFile(hReplacedFile, replacedData, sizeof(replacedData), &ret, NULL );
2893 ok( retok && ret == sizeof(replacedData),
2894 "WriteFile error (replaced) %d\n", GetLastError());
2895 ok(GetFileSize(hReplacedFile, NULL) == sizeof(replacedData),
2896 "replaced file has wrong size\n");
2897 /* place predictable data in the file to be the replacement */
2898 hReplacementFile = CreateFileA(replacement, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2899 ok(hReplacementFile != INVALID_HANDLE_VALUE,
2900 "failed to open replacement file\n");
2901 retok = WriteFile(hReplacementFile, replacementData, sizeof(replacementData), &ret, NULL );
2902 ok( retok && ret == sizeof(replacementData),
2903 "WriteFile error (replacement) %d\n", GetLastError());
2904 ok(GetFileSize(hReplacementFile, NULL) == sizeof(replacementData),
2905 "replacement file has wrong size\n");
2906 /* place predictable data in the backup file (to be over-written) */
2907 hBackupFile = CreateFileA(backup, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2908 ok(hBackupFile != INVALID_HANDLE_VALUE,
2909 "failed to open backup file\n");
2910 retok = WriteFile(hBackupFile, backupData, sizeof(backupData), &ret, NULL );
2911 ok( retok && ret == sizeof(backupData),
2912 "WriteFile error (replacement) %d\n", GetLastError());
2913 ok(GetFileSize(hBackupFile, NULL) == sizeof(backupData),
2914 "backup file has wrong size\n");
2915 /* change the filetime on the "replaced" file to ensure that it changes */
2916 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2917 ok( ret, "GetFileTime error (replaced) %d\n", GetLastError());
2918 ftReplaced.dwLowDateTime -= 600000000; /* 60 second */
2919 ret = SetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2920 ok( ret, "SetFileTime error (replaced) %d\n", GetLastError());
2921 GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced); /* get the actual time back */
2922 CloseHandle(hReplacedFile);
2923 /* change the filetime on the backup to ensure that it changes */
2924 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2925 ok( ret, "GetFileTime error (backup) %d\n", GetLastError());
2926 ftBackup.dwLowDateTime -= 1200000000; /* 120 second */
2927 ret = SetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2928 ok( ret, "SetFileTime error (backup) %d\n", GetLastError());
2929 GetFileTime(hBackupFile, NULL, NULL, &ftBackup); /* get the actual time back */
2930 CloseHandle(hBackupFile);
2931 /* get the filetime on the replacement file to perform checks */
2932 ret = GetFileTime(hReplacementFile, NULL, NULL, &ftReplacement);
2933 ok( ret, "GetFileTime error (replacement) %d\n", GetLastError());
2934 CloseHandle(hReplacementFile);
2935
2936 /* perform replacement w/ backup
2937 * TODO: flags are not implemented
2938 */
2939 SetLastError(0xdeadbeef);
2940 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
2941 ok(ret, "ReplaceFileA: unexpected error %d\n", GetLastError());
2942 /* make sure that the backup has the size of the old "replaced" file */
2943 hBackupFile = CreateFileA(backup, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2944 ok(hBackupFile != INVALID_HANDLE_VALUE,
2945 "failed to open backup file\n");
2946 ret = GetFileSize(hBackupFile, NULL);
2947 ok(ret == sizeof(replacedData),
2948 "backup file has wrong size %d\n", ret);
2949 /* make sure that the "replaced" file has the size of the replacement file */
2950 hReplacedFile = CreateFileA(replaced, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2951 ok(hReplacedFile != INVALID_HANDLE_VALUE,
2952 "failed to open replaced file: %d\n", GetLastError());
2953 if (hReplacedFile != INVALID_HANDLE_VALUE)
2954 {
2955 ret = GetFileSize(hReplacedFile, NULL);
2956 ok(ret == sizeof(replacementData),
2957 "replaced file has wrong size %d\n", ret);
2958 /* make sure that the replacement file no-longer exists */
2959 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2960 ok(hReplacementFile == INVALID_HANDLE_VALUE,
2961 "unexpected error, replacement file should not exist %d\n", GetLastError());
2962 /* make sure that the backup has the old "replaced" filetime */
2963 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2964 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
2965 ok(check_file_time(&ftBackup, &ftReplaced, 20000000), "backup file has wrong filetime\n");
2966 CloseHandle(hBackupFile);
2967 /* make sure that the "replaced" has the old replacement filetime */
2968 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2969 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
2970 ok(check_file_time(&ftReplaced, &ftReplacement, 20000000),
2971 "replaced file has wrong filetime %x%08x / %x%08x\n",
2972 ftReplaced.dwHighDateTime, ftReplaced.dwLowDateTime,
2973 ftReplacement.dwHighDateTime, ftReplacement.dwLowDateTime );
2974 CloseHandle(hReplacedFile);
2975 }
2976 else
2977 skip("couldn't open replacement file, skipping tests\n");
2978
2979 /* re-create replacement file for pass w/o backup (blank) */
2980 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2981 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2982 /* perform replacement w/o backup
2983 * TODO: flags are not implemented
2984 */
2985 SetLastError(0xdeadbeef);
2986 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
2987 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2988 "ReplaceFileA: unexpected error %d\n", GetLastError());
2989
2990 /* re-create replacement file for pass w/ backup (backup-file not existing) */
2991 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2992 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2993 ret = DeleteFileA(backup);
2994 ok(ret, "DeleteFileA: error (backup) %d\n", GetLastError());
2995 /* perform replacement w/ backup (no pre-existing backup)
2996 * TODO: flags are not implemented
2997 */
2998 SetLastError(0xdeadbeef);
2999 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3000 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3001 "ReplaceFileA: unexpected error %d\n", GetLastError());
3002 if (ret)
3003 removeBackup = TRUE;
3004
3005 /* re-create replacement file for pass w/ no permissions to "replaced" */
3006 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
3007 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3008 ret = SetFileAttributesA(replaced, FILE_ATTRIBUTE_READONLY);
3009 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3010 "SetFileAttributesA: error setting to read only %d\n", GetLastError());
3011 /* perform replacement w/ backup (no permission to "replaced")
3012 * TODO: flags are not implemented
3013 */
3014 SetLastError(0xdeadbeef);
3015 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3016 ok(ret != ERROR_UNABLE_TO_REMOVE_REPLACED, "ReplaceFileA: unexpected error %d\n", GetLastError());
3017 /* make sure that the replacement file still exists */
3018 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
3019 ok(hReplacementFile != INVALID_HANDLE_VALUE ||
3020 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* win2k */
3021 "unexpected error, replacement file should still exist %d\n", GetLastError());
3022 CloseHandle(hReplacementFile);
3023 ret = SetFileAttributesA(replaced, FILE_ATTRIBUTE_NORMAL);
3024 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3025 "SetFileAttributesA: error setting to normal %d\n", GetLastError());
3026
3027 /* replacement file still exists, make pass w/o "replaced" */
3028 ret = DeleteFileA(replaced);
3029 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3030 "DeleteFileA: error (replaced) %d\n", GetLastError());
3031 /* perform replacement w/ backup (no pre-existing backup or "replaced")
3032 * TODO: flags are not implemented
3033 */
3034 SetLastError(0xdeadbeef);
3035 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3036 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3037 GetLastError() == ERROR_ACCESS_DENIED),
3038 "ReplaceFileA: unexpected error %d\n", GetLastError());
3039
3040 /* perform replacement w/o existing "replacement" file
3041 * TODO: flags are not implemented
3042 */
3043 SetLastError(0xdeadbeef);
3044 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
3045 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3046 GetLastError() == ERROR_ACCESS_DENIED),
3047 "ReplaceFileA: unexpected error %d\n", GetLastError());
3048 DeleteFileA( replacement );
3049
3050 /*
3051 * if the first round (w/ backup) worked then as long as there is no
3052 * failure then there is no need to check this round (w/ backup is the
3053 * more complete case)
3054 */
3055
3056 /* delete temporary files, replacement and replaced are already deleted */
3057 if (removeBackup)
3058 {
3059 ret = DeleteFileA(backup);
3060 ok(ret ||
3061 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3062 "DeleteFileA: error (backup) %d\n", GetLastError());
3063 }
3064 }
3065
3066 /*
3067 * ReplaceFileW is a simpler case of ReplaceFileA, there is no
3068 * need to be as thorough.
3069 */
3070 static void test_ReplaceFileW(void)
3071 {
3072 WCHAR replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
3073 static const WCHAR prefix[] = {'p','f','x',0};
3074 WCHAR temp_path[MAX_PATH];
3075 DWORD ret;
3076 BOOL removeBackup = FALSE;
3077
3078 if (!pReplaceFileW)
3079 {
3080 win_skip("ReplaceFileW() is missing\n");
3081 return;
3082 }
3083
3084 ret = GetTempPathW(MAX_PATH, temp_path);
3085 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3086 {
3087 win_skip("GetTempPathW is not available\n");
3088 return;
3089 }
3090 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
3091 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
3092
3093 ret = GetTempFileNameW(temp_path, prefix, 0, replaced);
3094 ok(ret != 0, "GetTempFileNameW error (replaced) %d\n", GetLastError());
3095
3096 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3097 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3098
3099 ret = GetTempFileNameW(temp_path, prefix, 0, backup);
3100 ok(ret != 0, "GetTempFileNameW error (backup) %d\n", GetLastError());
3101
3102 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3103 ok(ret, "ReplaceFileW: error %d\n", GetLastError());
3104
3105 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3106 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3107 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3108 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3109 "ReplaceFileW: error %d\n", GetLastError());
3110
3111 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3112 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3113 ret = DeleteFileW(backup);
3114 ok(ret, "DeleteFileW: error (backup) %d\n", GetLastError());
3115 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3116 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3117 "ReplaceFileW: error %d\n", GetLastError());
3118
3119 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3120 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3121 ret = SetFileAttributesW(replaced, FILE_ATTRIBUTE_READONLY);
3122 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3123 "SetFileAttributesW: error setting to read only %d\n", GetLastError());
3124
3125 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3126 ok(ret != ERROR_UNABLE_TO_REMOVE_REPLACED,
3127 "ReplaceFileW: unexpected error %d\n", GetLastError());
3128 ret = SetFileAttributesW(replaced, FILE_ATTRIBUTE_NORMAL);
3129 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3130 "SetFileAttributesW: error setting to normal %d\n", GetLastError());
3131 if (ret)
3132 removeBackup = TRUE;
3133
3134 ret = DeleteFileW(replaced);
3135 ok(ret, "DeleteFileW: error (replaced) %d\n", GetLastError());
3136 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3137 ok(!ret, "ReplaceFileW: error %d\n", GetLastError());
3138
3139 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3140 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3141 GetLastError() == ERROR_ACCESS_DENIED),
3142 "ReplaceFileW: unexpected error %d\n", GetLastError());
3143 DeleteFileW( replacement );
3144
3145 if (removeBackup)
3146 {
3147 ret = DeleteFileW(backup);
3148 ok(ret ||
3149 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3150 "DeleteFileW: error (backup) %d\n", GetLastError());
3151 }
3152 }
3153
3154 START_TEST(file)
3155 {
3156 InitFunctionPointers();
3157
3158 test__hread( );
3159 test__hwrite( );
3160 test__lclose( );
3161 test__lcreat( );
3162 test__llseek( );
3163 test__llopen( );
3164 test__lread( );
3165 test__lwrite( );
3166 test_GetTempFileNameA();
3167 test_CopyFileA();
3168 test_CopyFileW();
3169 test_CreateFileA();
3170 test_CreateFileW();
3171 test_DeleteFileA();
3172 test_DeleteFileW();
3173 test_MoveFileA();
3174 test_MoveFileW();
3175 test_FindFirstFileA();
3176 test_FindNextFileA();
3177 test_FindFirstFileExA(0);
3178 /* FindExLimitToDirectories is ignored if the file system doesn't support directory filtering */
3179 test_FindFirstFileExA(FindExSearchLimitToDirectories);
3180 test_LockFile();
3181 test_file_sharing();
3182 test_offset_in_overlapped_structure();
3183 test_MapFile();
3184 test_GetFileType();
3185 test_async_file_errors();
3186 test_read_write();
3187 test_OpenFile();
3188 test_overlapped();
3189 test_RemoveDirectory();
3190 test_ReplaceFileA();
3191 test_ReplaceFileW();
3192 }
Maarten's multimedia branch