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