?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Pass a wined3d_gl_info structure to send_attribute().
[wine/multimedia.git] / dlls / kernel32 / tests / file.c
blob375b5f0367db1cc1e7b927e70c85538dbdec2617
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 #elif defined __arm__
1733 nt->FileHeader.Machine = IMAGE_FILE_MACHINE_ARM;
1734 #else
1735 # error You must specify the machine type
1736 #endif
1737 nt->FileHeader.NumberOfSections = 1;
1738 nt->FileHeader.SizeOfOptionalHeader = IMAGE_SIZEOF_NT_OPTIONAL_HEADER;
1739 nt->FileHeader.Characteristics = IMAGE_FILE_DLL | IMAGE_FILE_EXECUTABLE_IMAGE;
1740 nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
1741 nt->OptionalHeader.MajorLinkerVersion = 1;
1742 nt->OptionalHeader.MinorLinkerVersion = 0;
1743 nt->OptionalHeader.ImageBase = 0x10000000;
1744 nt->OptionalHeader.SectionAlignment = 0x1000;
1745 nt->OptionalHeader.FileAlignment = 0x1000;
1746 nt->OptionalHeader.MajorOperatingSystemVersion = 1;
1747 nt->OptionalHeader.MinorOperatingSystemVersion = 0;
1748 nt->OptionalHeader.MajorImageVersion = 1;
1749 nt->OptionalHeader.MinorImageVersion = 0;
1750 nt->OptionalHeader.MajorSubsystemVersion = 4;
1751 nt->OptionalHeader.MinorSubsystemVersion = 0;
1752 nt->OptionalHeader.SizeOfImage = 0x2000;
1753 nt->OptionalHeader.SizeOfHeaders = size;
1754 nt->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_GUI;
1755 nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
1756
1757 sec = (IMAGE_SECTION_HEADER *)(nt + 1);
1758 memcpy( sec->Name, ".rodata", sizeof(".rodata") );
1759 sec->Misc.VirtualSize = 0x1000;
1760 sec->VirtualAddress = 0x1000;
1761 sec->SizeOfRawData = 0;
1762 sec->PointerToRawData = 0;
1763 sec->Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
1764
1765 ret = WriteFile( file, buffer, size, &written, NULL ) && written == size;
1766 HeapFree( GetProcessHeap(), 0, buffer );
1767 CloseHandle( file );
1768 return ret;
1769 }
1770
1771 static int is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2, BOOL is_win9x )
1772 {
1773 if (!is_win9x)
1774 {
1775 if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1776 if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1777 }
1778 else
1779 {
1780 access1 &= ~DELETE;
1781 if (!access1) access1 = GENERIC_READ;
1782
1783 access2 &= ~DELETE;
1784 if (!access2) access2 = GENERIC_READ;
1785 }
1786
1787 if ((access1 & GENERIC_READ) && !(sharing2 & FILE_SHARE_READ)) return 0;
1788 if ((access1 & GENERIC_WRITE) && !(sharing2 & FILE_SHARE_WRITE)) return 0;
1789 if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return 0;
1790 if ((access2 & GENERIC_READ) && !(sharing1 & FILE_SHARE_READ)) return 0;
1791 if ((access2 & GENERIC_WRITE) && !(sharing1 & FILE_SHARE_WRITE)) return 0;
1792 if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return 0;
1793 return 1;
1794 }
1795
1796 static int is_sharing_map_compatible( DWORD map_access, DWORD access2, DWORD sharing2 )
1797 {
1798 if ((map_access == PAGE_READWRITE || map_access == PAGE_EXECUTE_READWRITE) &&
1799 !(sharing2 & FILE_SHARE_WRITE)) return 0;
1800 if ((map_access & SEC_IMAGE) && (access2 & GENERIC_WRITE)) return 0;
1801 return 1;
1802 }
1803
1804 static void test_file_sharing(void)
1805 {
1806 static const DWORD access_modes[] =
1807 { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ|GENERIC_WRITE,
1808 DELETE, GENERIC_READ|DELETE, GENERIC_WRITE|DELETE, GENERIC_READ|GENERIC_WRITE|DELETE };
1809 static const DWORD sharing_modes[] =
1810 { 0, FILE_SHARE_READ,
1811 FILE_SHARE_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1812 FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_DELETE,
1813 FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE };
1814 static const DWORD mapping_modes[] =
1815 { PAGE_READONLY, PAGE_WRITECOPY, PAGE_READWRITE, SEC_IMAGE | PAGE_WRITECOPY };
1816 int a1, s1, a2, s2;
1817 int ret;
1818 HANDLE h, h2;
1819 BOOL is_win9x = FALSE;
1820
1821 /* make sure the file exists */
1822 if (!create_fake_dll( filename ))
1823 {
1824 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
1825 return;
1826 }
1827 is_win9x = GetFileAttributesW(filenameW) == INVALID_FILE_ATTRIBUTES;
1828
1829 for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
1830 {
1831 for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
1832 {
1833 /* Win9x doesn't support FILE_SHARE_DELETE */
1834 if (is_win9x && (sharing_modes[s1] & FILE_SHARE_DELETE))
1835 continue;
1836
1837 SetLastError(0xdeadbeef);
1838 h = CreateFileA( filename, access_modes[a1], sharing_modes[s1],
1839 NULL, OPEN_EXISTING, 0, 0 );
1840 if (h == INVALID_HANDLE_VALUE)
1841 {
1842 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1843 return;
1844 }
1845 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1846 {
1847 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1848 {
1849 /* Win9x doesn't support FILE_SHARE_DELETE */
1850 if (is_win9x && (sharing_modes[s2] & FILE_SHARE_DELETE))
1851 continue;
1852
1853 SetLastError(0xdeadbeef);
1854 h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1855 NULL, OPEN_EXISTING, 0, 0 );
1856 ret = GetLastError();
1857 if (is_sharing_compatible( access_modes[a1], sharing_modes[s1],
1858 access_modes[a2], sharing_modes[s2], is_win9x ))
1859 {
1860 ok( h2 != INVALID_HANDLE_VALUE,
1861 "open failed for modes %x/%x/%x/%x\n",
1862 access_modes[a1], sharing_modes[s1],
1863 access_modes[a2], sharing_modes[s2] );
1864 ok( ret == 0xdeadbeef /* Win9x */ ||
1865 ret == 0, /* XP */
1866 "wrong error code %d\n", ret );
1867 }
1868 else
1869 {
1870 ok( h2 == INVALID_HANDLE_VALUE,
1871 "open succeeded for modes %x/%x/%x/%x\n",
1872 access_modes[a1], sharing_modes[s1],
1873 access_modes[a2], sharing_modes[s2] );
1874 ok( ret == ERROR_SHARING_VIOLATION,
1875 "wrong error code %d\n", ret );
1876 }
1877 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1878 }
1879 }
1880 CloseHandle( h );
1881 }
1882 }
1883
1884 for (a1 = 0; a1 < sizeof(mapping_modes)/sizeof(mapping_modes[0]); a1++)
1885 {
1886 HANDLE m;
1887
1888 create_fake_dll( filename );
1889 SetLastError(0xdeadbeef);
1890 h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
1891 if (h == INVALID_HANDLE_VALUE)
1892 {
1893 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1894 return;
1895 }
1896 m = CreateFileMappingA( h, NULL, mapping_modes[a1], 0, 0, NULL );
1897 ok( m != 0, "failed to create mapping %x err %u\n", mapping_modes[a1], GetLastError() );
1898 CloseHandle( h );
1899 if (!m) continue;
1900
1901 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1902 {
1903 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1904 {
1905 /* Win9x doesn't support FILE_SHARE_DELETE */
1906 if (is_win9x && (sharing_modes[s2] & FILE_SHARE_DELETE))
1907 continue;
1908
1909 SetLastError(0xdeadbeef);
1910 h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1911 NULL, OPEN_EXISTING, 0, 0 );
1912
1913 ret = GetLastError();
1914 if (h2 == INVALID_HANDLE_VALUE)
1915 {
1916 if (is_sharing_map_compatible(mapping_modes[a1], access_modes[a2], sharing_modes[s2]))
1917 ok( is_win9x, /* there's no sharing at all with a mapping on win9x */
1918 "open failed for modes map %x/%x/%x\n",
1919 mapping_modes[a1], access_modes[a2], sharing_modes[s2] );
1920 ok( ret == ERROR_SHARING_VIOLATION,
1921 "wrong error code %d\n", ret );
1922 }
1923 else
1924 {
1925 if (!is_sharing_map_compatible(mapping_modes[a1], access_modes[a2], sharing_modes[s2]))
1926 ok( broken(1), /* no checking on nt4 */
1927 "open succeeded for modes map %x/%x/%x\n",
1928 mapping_modes[a1], access_modes[a2], sharing_modes[s2] );
1929 ok( ret == 0xdeadbeef /* Win9x */ ||
1930 ret == 0, /* XP */
1931 "wrong error code %d\n", ret );
1932 CloseHandle( h2 );
1933 }
1934 }
1935 }
1936
1937 /* try CREATE_ALWAYS over an existing mapping */
1938 SetLastError(0xdeadbeef);
1939 h2 = CreateFileA( filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
1940 NULL, CREATE_ALWAYS, 0, 0 );
1941 ret = GetLastError();
1942 if ((mapping_modes[a1] & SEC_IMAGE) || is_win9x)
1943 {
1944 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1945 ok( ret == ERROR_SHARING_VIOLATION, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1946 }
1947 else
1948 {
1949 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1950 ok( ret == ERROR_USER_MAPPED_FILE, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1951 }
1952 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1953
1954 /* try DELETE_ON_CLOSE over an existing mapping */
1955 SetLastError(0xdeadbeef);
1956 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
1957 NULL, OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, 0 );
1958 ret = GetLastError();
1959 if (is_win9x)
1960 {
1961 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1962 ok( ret == ERROR_SHARING_VIOLATION, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1963 }
1964 else if (mapping_modes[a1] & SEC_IMAGE)
1965 {
1966 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %x\n", mapping_modes[a1] );
1967 ok( ret == ERROR_ACCESS_DENIED, "wrong error code %d for %x\n", ret, mapping_modes[a1] );
1968 }
1969 else
1970 {
1971 ok( h2 != INVALID_HANDLE_VALUE, "open failed for map %x err %u\n", mapping_modes[a1], ret );
1972 }
1973 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1974
1975 CloseHandle( m );
1976 }
1977
1978 SetLastError(0xdeadbeef);
1979 h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, 0 );
1980 ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
1981
1982 SetLastError(0xdeadbeef);
1983 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1984 ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
1985 ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %d\n", GetLastError() );
1986
1987 h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
1988 ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
1989
1990 CloseHandle(h);
1991 CloseHandle(h2);
1992
1993 DeleteFileA( filename );
1994 }
1995
1996 static char get_windows_drive(void)
1997 {
1998 char windowsdir[MAX_PATH];
1999 GetWindowsDirectory(windowsdir, sizeof(windowsdir));
2000 return windowsdir[0];
2001 }
2002
2003 static void test_FindFirstFileA(void)
2004 {
2005 HANDLE handle;
2006 WIN32_FIND_DATAA data;
2007 int err;
2008 char buffer[5] = "C:\\";
2009 char buffer2[100];
2010 char nonexistent[MAX_PATH];
2011
2012 /* try FindFirstFileA on "C:\" */
2013 buffer[0] = get_windows_drive();
2014
2015 SetLastError( 0xdeadbeaf );
2016 handle = FindFirstFileA(buffer, &data);
2017 err = GetLastError();
2018 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on root directory should fail\n" );
2019 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2020
2021 /* try FindFirstFileA on "C:\*" */
2022 strcpy(buffer2, buffer);
2023 strcat(buffer2, "*");
2024 handle = FindFirstFileA(buffer2, &data);
2025 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2026 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2027 "FindFirstFile shouldn't return '%s' in drive root\n", data.cFileName );
2028 if (FindNextFileA( handle, &data ))
2029 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2030 "FindNextFile shouldn't return '%s' in drive root\n", data.cFileName );
2031 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2032
2033 /* try FindFirstFileA on windows dir */
2034 GetWindowsDirectory( buffer2, sizeof(buffer2) );
2035 strcat(buffer2, "\\*");
2036 handle = FindFirstFileA(buffer2, &data);
2037 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2038 ok( !strcmp( data.cFileName, "." ), "FindFirstFile should return '.' first\n" );
2039 ok( FindNextFileA( handle, &data ), "FindNextFile failed\n" );
2040 ok( !strcmp( data.cFileName, ".." ), "FindNextFile should return '..' as second entry\n" );
2041 while (FindNextFileA( handle, &data ))
2042 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2043 "FindNextFile shouldn't return '%s'\n", data.cFileName );
2044 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2045
2046 /* try FindFirstFileA on "C:\foo\" */
2047 SetLastError( 0xdeadbeaf );
2048 if (!GetTempFileNameA( buffer, "foo", 0, nonexistent ) && GetLastError() == ERROR_ACCESS_DENIED)
2049 {
2050 char tmp[MAX_PATH];
2051 GetTempPathA( sizeof(tmp), tmp );
2052 GetTempFileNameA( tmp, "foo", 0, nonexistent );
2053 }
2054 DeleteFileA( nonexistent );
2055 strcpy(buffer2, nonexistent);
2056 strcat(buffer2, "\\");
2057 handle = FindFirstFileA(buffer2, &data);
2058 err = GetLastError();
2059 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2060 todo_wine {
2061 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2062 }
2063
2064 /* try FindFirstFileA on "C:\foo\bar.txt" */
2065 SetLastError( 0xdeadbeaf );
2066 strcpy(buffer2, nonexistent);
2067 strcat(buffer2, "\\bar.txt");
2068 handle = FindFirstFileA(buffer2, &data);
2069 err = GetLastError();
2070 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2071 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2072
2073 /* try FindFirstFileA on "C:\foo\*.*" */
2074 SetLastError( 0xdeadbeaf );
2075 strcpy(buffer2, nonexistent);
2076 strcat(buffer2, "\\*.*");
2077 handle = FindFirstFileA(buffer2, &data);
2078 err = GetLastError();
2079 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2080 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2081
2082 /* try FindFirstFileA on "foo\bar.txt" */
2083 SetLastError( 0xdeadbeaf );
2084 strcpy(buffer2, nonexistent + 3);
2085 strcat(buffer2, "\\bar.txt");
2086 handle = FindFirstFileA(buffer2, &data);
2087 err = GetLastError();
2088 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2089 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2090
2091 /* try FindFirstFileA on "c:\nul" */
2092 SetLastError( 0xdeadbeaf );
2093 strcpy(buffer2, buffer);
2094 strcat(buffer2, "nul");
2095 handle = FindFirstFileA(buffer2, &data);
2096 err = GetLastError();
2097 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed\n", buffer2 );
2098 ok( 0 == lstrcmpiA(data.cFileName, "nul"), "wrong name %s\n", data.cFileName );
2099 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2100 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2101 "wrong attributes %x\n", data.dwFileAttributes );
2102 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2103 {
2104 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2105 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2106 }
2107 SetLastError( 0xdeadbeaf );
2108 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2109 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2110 ok( FindClose( handle ), "failed to close handle\n" );
2111
2112 /* try FindFirstFileA on "lpt1" */
2113 SetLastError( 0xdeadbeaf );
2114 strcpy(buffer2, "lpt1");
2115 handle = FindFirstFileA(buffer2, &data);
2116 err = GetLastError();
2117 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed\n", buffer2 );
2118 ok( 0 == lstrcmpiA(data.cFileName, "lpt1"), "wrong name %s\n", data.cFileName );
2119 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2120 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2121 "wrong attributes %x\n", data.dwFileAttributes );
2122 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2123 {
2124 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2125 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2126 }
2127 SetLastError( 0xdeadbeaf );
2128 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2129 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2130 ok( FindClose( handle ), "failed to close handle\n" );
2131
2132 /* try FindFirstFileA on "c:\nul\*" */
2133 SetLastError( 0xdeadbeaf );
2134 strcpy(buffer2, buffer);
2135 strcat(buffer2, "nul\\*");
2136 handle = FindFirstFileA(buffer2, &data);
2137 err = GetLastError();
2138 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2139 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2140
2141 /* try FindFirstFileA on "c:\nul*" */
2142 SetLastError( 0xdeadbeaf );
2143 strcpy(buffer2, buffer);
2144 strcat(buffer2, "nul*");
2145 handle = FindFirstFileA(buffer2, &data);
2146 err = GetLastError();
2147 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2148 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2149
2150 /* try FindFirstFileA on "c:\foo\bar\nul" */
2151 SetLastError( 0xdeadbeaf );
2152 strcpy(buffer2, buffer);
2153 strcat(buffer2, "foo\\bar\\nul");
2154 handle = FindFirstFileA(buffer2, &data);
2155 err = GetLastError();
2156 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2157 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2158
2159 /* try FindFirstFileA on "c:\foo\nul\bar" */
2160 SetLastError( 0xdeadbeaf );
2161 strcpy(buffer2, buffer);
2162 strcat(buffer2, "foo\\nul\\bar");
2163 handle = FindFirstFileA(buffer2, &data);
2164 err = GetLastError();
2165 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
2166 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2167 }
2168
2169 static void test_FindNextFileA(void)
2170 {
2171 HANDLE handle;
2172 WIN32_FIND_DATAA search_results;
2173 int err;
2174 char buffer[5] = "C:\\*";
2175
2176 buffer[0] = get_windows_drive();
2177 handle = FindFirstFileA(buffer,&search_results);
2178 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
2179 while (FindNextFile(handle, &search_results))
2180 {
2181 /* get to the end of the files */
2182 }
2183 ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
2184 err = GetLastError();
2185 ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
2186 }
2187
2188 static void test_FindFirstFileExA(FINDEX_SEARCH_OPS search_ops)
2189 {
2190 WIN32_FIND_DATAA search_results;
2191 HANDLE handle;
2192 BOOL ret;
2193
2194 if (!pFindFirstFileExA)
2195 {
2196 win_skip("FindFirstFileExA() is missing\n");
2197 return;
2198 }
2199
2200 CreateDirectoryA("test-dir", NULL);
2201 _lclose(_lcreat("test-dir\\file1", 0));
2202 _lclose(_lcreat("test-dir\\file2", 0));
2203 CreateDirectoryA("test-dir\\dir1", NULL);
2204 SetLastError(0xdeadbeef);
2205 handle = pFindFirstFileExA("test-dir\\*", FindExInfoStandard, &search_results, search_ops, NULL, 0);
2206 if (handle == INVALID_HANDLE_VALUE && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2207 {
2208 win_skip("FindFirstFileExA is not implemented\n");
2209 goto cleanup;
2210 }
2211 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFile failed (err=%u)\n", GetLastError());
2212 ok(strcmp(search_results.cFileName, ".") == 0, "First entry should be '.', is %s\n", search_results.cFileName);
2213
2214 #define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
2215
2216 ok(FindNextFile(handle, &search_results), "Fetching second file failed\n");
2217 ok(strcmp(search_results.cFileName, "..") == 0, "Second entry should be '..' is %s\n", search_results.cFileName);
2218
2219 ok(FindNextFile(handle, &search_results), "Fetching third file failed\n");
2220 ok(CHECK_NAME(search_results.cFileName), "Invalid third entry - %s\n", search_results.cFileName);
2221
2222 SetLastError(0xdeadbeef);
2223 ret = FindNextFile(handle, &search_results);
2224 if (!ret && (GetLastError() == ERROR_NO_MORE_FILES) && (search_ops == FindExSearchLimitToDirectories))
2225 {
2226 skip("File system supports directory filtering\n");
2227 /* Results from the previous call are not cleared */
2228 ok(strcmp(search_results.cFileName, "dir1") == 0, "Third entry should be 'dir1' is %s\n", search_results.cFileName);
2229 FindClose( handle );
2230 goto cleanup;
2231 }
2232
2233 ok(ret, "Fetching fourth file failed\n");
2234 ok(CHECK_NAME(search_results.cFileName), "Invalid fourth entry - %s\n", search_results.cFileName);
2235
2236 ok(FindNextFile(handle, &search_results), "Fetching fifth file failed\n");
2237 ok(CHECK_NAME(search_results.cFileName), "Invalid fifth entry - %s\n", search_results.cFileName);
2238
2239 #undef CHECK_NAME
2240
2241 ok(FindNextFile(handle, &search_results) == FALSE, "Fetching sixth file should fail\n");
2242
2243 FindClose( handle );
2244
2245 cleanup:
2246 DeleteFileA("test-dir\\file1");
2247 DeleteFileA("test-dir\\file2");
2248 RemoveDirectoryA("test-dir\\dir1");
2249 RemoveDirectoryA("test-dir");
2250 }
2251
2252 static int test_Mapfile_createtemp(HANDLE *handle)
2253 {
2254 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL);
2255 DeleteFile(filename);
2256 *handle = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 0,
2257 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2258 if (*handle != INVALID_HANDLE_VALUE) {
2259
2260 return 1;
2261 }
2262
2263 return 0;
2264 }
2265
2266 static void test_MapFile(void)
2267 {
2268 HANDLE handle;
2269 HANDLE hmap;
2270
2271 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
2272
2273 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
2274 ok( hmap != NULL, "mapping should work, I named it!\n" );
2275
2276 ok( CloseHandle( hmap ), "can't close mapping handle\n");
2277
2278 /* We have to close file before we try new stuff with mapping again.
2279 Else we would always succeed on XP or block descriptors on 95. */
2280 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
2281 ok( hmap != NULL, "We should still be able to map!\n" );
2282 ok( CloseHandle( hmap ), "can't close mapping handle\n");
2283 ok( CloseHandle( handle ), "can't close file handle\n");
2284 handle = NULL;
2285
2286 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
2287
2288 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
2289 ok( hmap == NULL, "mapped zero size file\n");
2290 ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
2291
2292 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0, NULL );
2293 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
2294 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2295 if ( hmap )
2296 CloseHandle( hmap );
2297
2298 hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0x10000, NULL );
2299 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
2300 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2301 if ( hmap )
2302 CloseHandle( hmap );
2303
2304 /* On XP you can now map again, on Win 95 you cannot. */
2305
2306 ok( CloseHandle( handle ), "can't close file handle\n");
2307 ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
2308 }
2309
2310 static void test_GetFileType(void)
2311 {
2312 DWORD type;
2313 HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
2314 ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
2315 type = GetFileType(h);
2316 ok( type == FILE_TYPE_DISK, "expected type disk got %d\n", type );
2317 CloseHandle( h );
2318 h = CreateFileA( "nul", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2319 ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
2320 type = GetFileType(h);
2321 ok( type == FILE_TYPE_CHAR, "expected type char for nul got %d\n", type );
2322 CloseHandle( h );
2323 DeleteFileA( filename );
2324 }
2325
2326 static int completion_count;
2327
2328 static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
2329 {
2330 /* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
2331 ReleaseSemaphore(ovl->hEvent, 1, NULL);
2332 completion_count++;
2333 }
2334
2335 static void test_async_file_errors(void)
2336 {
2337 char szFile[MAX_PATH];
2338 HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
2339 HANDLE hFile;
2340 LPVOID lpBuffer = HeapAlloc(GetProcessHeap(), 0, 4096);
2341 OVERLAPPED ovl;
2342 S(U(ovl)).Offset = 0;
2343 S(U(ovl)).OffsetHigh = 0;
2344 ovl.hEvent = hSem;
2345 completion_count = 0;
2346 szFile[0] = '\0';
2347 GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
2348 strcat(szFile, "\\win.ini");
2349 hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2350 NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
2351 if (hFile == INVALID_HANDLE_VALUE) /* win9x doesn't like FILE_SHARE_DELETE */
2352 hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
2353 NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
2354 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA(%s ...) failed\n", szFile);
2355 while (TRUE)
2356 {
2357 BOOL res;
2358 DWORD count;
2359 while (WaitForSingleObjectEx(hSem, INFINITE, TRUE) == WAIT_IO_COMPLETION)
2360 ;
2361 res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
2362 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
2363 if (!res)
2364 break;
2365 if (!GetOverlappedResult(hFile, &ovl, &count, FALSE))
2366 break;
2367 S(U(ovl)).Offset += count;
2368 /* i/o completion routine only called if ReadFileEx returned success.
2369 * we only care about violations of this rule so undo what should have
2370 * been done */
2371 completion_count--;
2372 }
2373 ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
2374 /*printf("Error = %ld\n", GetLastError());*/
2375 HeapFree(GetProcessHeap(), 0, lpBuffer);
2376 }
2377
2378 static void test_read_write(void)
2379 {
2380 DWORD bytes, ret, old_prot;
2381 HANDLE hFile;
2382 char temp_path[MAX_PATH];
2383 char filename[MAX_PATH];
2384 char *mem;
2385 static const char prefix[] = "pfx";
2386
2387 ret = GetTempPathA(MAX_PATH, temp_path);
2388 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
2389 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
2390
2391 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
2392 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
2393
2394 hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
2395 CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
2396 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
2397
2398 SetLastError(12345678);
2399 bytes = 12345678;
2400 ret = WriteFile(hFile, NULL, 0, &bytes, NULL);
2401 ok(ret && GetLastError() == 12345678,
2402 "ret = %d, error %d\n", ret, GetLastError());
2403 ok(!bytes, "bytes = %d\n", bytes);
2404
2405 SetLastError(12345678);
2406 bytes = 12345678;
2407 ret = WriteFile(hFile, NULL, 10, &bytes, NULL);
2408 ok((!ret && GetLastError() == ERROR_INVALID_USER_BUFFER) || /* Win2k */
2409 (ret && GetLastError() == 12345678), /* Win9x */
2410 "ret = %d, error %d\n", ret, GetLastError());
2411 ok(!bytes || /* Win2k */
2412 bytes == 10, /* Win9x */
2413 "bytes = %d\n", bytes);
2414
2415 /* make sure the file contains data */
2416 WriteFile(hFile, "this is the test data", 21, &bytes, NULL);
2417 SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
2418
2419 SetLastError(12345678);
2420 bytes = 12345678;
2421 ret = ReadFile(hFile, NULL, 0, &bytes, NULL);
2422 ok(ret && GetLastError() == 12345678,
2423 "ret = %d, error %d\n", ret, GetLastError());
2424 ok(!bytes, "bytes = %d\n", bytes);
2425
2426 SetLastError(12345678);
2427 bytes = 12345678;
2428 ret = ReadFile(hFile, NULL, 10, &bytes, NULL);
2429 ok(!ret && (GetLastError() == ERROR_NOACCESS || /* Win2k */
2430 GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
2431 "ret = %d, error %d\n", ret, GetLastError());
2432 ok(!bytes, "bytes = %d\n", bytes);
2433
2434 /* test passing protected memory as buffer */
2435
2436 mem = VirtualAlloc( NULL, 0x4000, MEM_COMMIT, PAGE_READWRITE );
2437 ok( mem != NULL, "failed to allocate virtual mem error %u\n", GetLastError() );
2438
2439 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2440 ok( ret, "WriteFile failed error %u\n", GetLastError() );
2441 ok( bytes == 0x4000, "only wrote %x bytes\n", bytes );
2442
2443 ret = VirtualProtect( mem + 0x2000, 0x2000, PAGE_NOACCESS, &old_prot );
2444 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2445
2446 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2447 ok( !ret, "WriteFile succeeded\n" );
2448 ok( GetLastError() == ERROR_INVALID_USER_BUFFER ||
2449 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2450 "wrong error %u\n", GetLastError() );
2451 ok( bytes == 0, "wrote %x bytes\n", bytes );
2452
2453 ret = WriteFile( (HANDLE)0xdead, mem, 0x4000, &bytes, NULL );
2454 ok( !ret, "WriteFile succeeded\n" );
2455 ok( GetLastError() == ERROR_INVALID_HANDLE || /* handle is checked before buffer on NT */
2456 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2457 "wrong error %u\n", GetLastError() );
2458 ok( bytes == 0, "wrote %x bytes\n", bytes );
2459
2460 ret = VirtualProtect( mem, 0x2000, PAGE_NOACCESS, &old_prot );
2461 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2462
2463 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
2464 ok( !ret, "WriteFile succeeded\n" );
2465 ok( GetLastError() == ERROR_INVALID_USER_BUFFER ||
2466 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2467 "wrong error %u\n", GetLastError() );
2468 ok( bytes == 0, "wrote %x bytes\n", bytes );
2469
2470 SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
2471
2472 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2473 ok( !ret, "ReadFile succeeded\n" );
2474 ok( GetLastError() == ERROR_NOACCESS ||
2475 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2476 "wrong error %u\n", GetLastError() );
2477 ok( bytes == 0, "read %x bytes\n", bytes );
2478
2479 ret = VirtualProtect( mem, 0x2000, PAGE_READONLY, &old_prot );
2480 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2481
2482 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2483 ok( !ret, "ReadFile succeeded\n" );
2484 ok( GetLastError() == ERROR_NOACCESS ||
2485 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2486 "wrong error %u\n", GetLastError() );
2487 ok( bytes == 0, "read %x bytes\n", bytes );
2488
2489 ret = VirtualProtect( mem, 0x2000, PAGE_READWRITE, &old_prot );
2490 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
2491
2492 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2493 ok( !ret, "ReadFile succeeded\n" );
2494 ok( GetLastError() == ERROR_NOACCESS ||
2495 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2496 "wrong error %u\n", GetLastError() );
2497 ok( bytes == 0, "read %x bytes\n", bytes );
2498
2499 SetFilePointer( hFile, 0x1234, NULL, FILE_BEGIN );
2500 SetEndOfFile( hFile );
2501 SetFilePointer( hFile, 0, NULL, FILE_BEGIN );
2502
2503 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
2504 ok( !ret, "ReadFile succeeded\n" );
2505 ok( GetLastError() == ERROR_NOACCESS ||
2506 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2507 "wrong error %u\n", GetLastError() );
2508 ok( bytes == 0, "read %x bytes\n", bytes );
2509
2510 ret = ReadFile( hFile, mem, 0x2000, &bytes, NULL );
2511 ok( ret, "ReadFile failed error %u\n", GetLastError() );
2512 ok( bytes == 0x1234, "read %x bytes\n", bytes );
2513
2514 ret = ReadFile( hFile, NULL, 1, &bytes, NULL );
2515 ok( !ret, "ReadFile succeeded\n" );
2516 ok( GetLastError() == ERROR_NOACCESS ||
2517 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
2518 "wrong error %u\n", GetLastError() );
2519 ok( bytes == 0, "read %x bytes\n", bytes );
2520
2521 VirtualFree( mem, 0, MEM_FREE );
2522
2523 ret = CloseHandle(hFile);
2524 ok( ret, "CloseHandle: error %d\n", GetLastError());
2525 ret = DeleteFileA(filename);
2526 ok( ret, "DeleteFileA: error %d\n", GetLastError());
2527 }
2528
2529 static void test_OpenFile(void)
2530 {
2531 HFILE hFile;
2532 OFSTRUCT ofs;
2533 BOOL ret;
2534 DWORD retval;
2535
2536 static const char file[] = "regedit.exe";
2537 static const char foo[] = ".\\foo-bar-foo.baz";
2538 static const char *foo_too_long = ".\\foo-bar-foo.baz+++++++++++++++"
2539 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2540 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2541 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2542 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2543 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
2544 char buff[MAX_PATH];
2545 char buff_long[4*MAX_PATH];
2546 char filled_0xA5[OFS_MAXPATHNAME];
2547 char *p;
2548 UINT length;
2549
2550 /* Check for existing file */
2551 if (!pGetSystemWindowsDirectoryA)
2552 length = GetWindowsDirectoryA(buff, MAX_PATH);
2553 else
2554 length = pGetSystemWindowsDirectoryA(buff, MAX_PATH);
2555
2556 if (length + sizeof(file) < MAX_PATH)
2557 {
2558 p = buff + strlen(buff);
2559 if (p > buff && p[-1] != '\\') *p++ = '\\';
2560 strcpy( p, file );
2561 memset(&ofs, 0xA5, sizeof(ofs));
2562 SetLastError(0xfaceabee);
2563
2564 hFile = OpenFile(buff, &ofs, OF_EXIST);
2565 ok( hFile == TRUE, "%s not found : %d\n", buff, GetLastError() );
2566 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2567 "GetLastError() returns %d\n", GetLastError() );
2568 ok( ofs.cBytes == sizeof(ofs), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2569 ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2570 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2571 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2572 ofs.szPathName, buff );
2573 }
2574
2575 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
2576 length = GetCurrentDirectoryA(MAX_PATH, buff);
2577
2578 /* Check for nonexistent file */
2579 if (length + sizeof(foo) < MAX_PATH)
2580 {
2581 p = buff + strlen(buff);
2582 if (p > buff && p[-1] != '\\') *p++ = '\\';
2583 strcpy( p, foo + 2 );
2584 memset(&ofs, 0xA5, sizeof(ofs));
2585 SetLastError(0xfaceabee);
2586
2587 hFile = OpenFile(foo, &ofs, OF_EXIST);
2588 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
2589 ok( GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError() returns %d\n", GetLastError() );
2590 todo_wine
2591 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2592 ok( ofs.nErrCode == ERROR_FILE_NOT_FOUND, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2593 ok( lstrcmpiA(ofs.szPathName, buff) == 0 || strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
2594 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2595 ofs.szPathName, buff );
2596 }
2597
2598 length = GetCurrentDirectoryA(MAX_PATH, buff_long);
2599 length += lstrlenA(foo_too_long + 1);
2600
2601 /* Check for nonexistent file with too long filename */
2602 if (length >= OFS_MAXPATHNAME && length < sizeof(buff_long))
2603 {
2604 lstrcatA(buff_long, foo_too_long + 1); /* Avoid '.' during concatenation */
2605 memset(&ofs, 0xA5, sizeof(ofs));
2606 SetLastError(0xfaceabee);
2607
2608 hFile = OpenFile(foo_too_long, &ofs, OF_EXIST);
2609 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
2610 ok( GetLastError() == ERROR_INVALID_DATA || GetLastError() == ERROR_FILENAME_EXCED_RANGE,
2611 "GetLastError() returns %d\n", GetLastError() );
2612 todo_wine
2613 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2614 ok( ofs.nErrCode == ERROR_INVALID_DATA || ofs.nErrCode == ERROR_FILENAME_EXCED_RANGE,
2615 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2616 ok( strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
2617 "OpenFile returned '%s', but was expected to return string filled with 0xA5\n",
2618 ofs.szPathName );
2619 }
2620
2621 length = GetCurrentDirectoryA(MAX_PATH, buff) + sizeof(filename);
2622
2623 if (length >= MAX_PATH)
2624 {
2625 trace("Buffer too small, requested length = %d, but MAX_PATH = %d. Skipping test.\n", length, MAX_PATH);
2626 return;
2627 }
2628 p = buff + strlen(buff);
2629 if (p > buff && p[-1] != '\\') *p++ = '\\';
2630 strcpy( p, filename );
2631
2632 memset(&ofs, 0xA5, sizeof(ofs));
2633 SetLastError(0xfaceabee);
2634 /* Create an empty file */
2635 hFile = OpenFile(filename, &ofs, OF_CREATE);
2636 ok( hFile != HFILE_ERROR, "OpenFile failed to create nonexistent file\n" );
2637 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2638 "GetLastError() returns %d\n", GetLastError() );
2639 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2640 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2641 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2642 ret = _lclose(hFile);
2643 ok( !ret, "_lclose() returns %d\n", ret );
2644 retval = GetFileAttributesA(filename);
2645 ok( retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %d\n", GetLastError() );
2646
2647 memset(&ofs, 0xA5, sizeof(ofs));
2648 SetLastError(0xfaceabee);
2649 /* Check various opening options: */
2650 /* for reading only, */
2651 hFile = OpenFile(filename, &ofs, OF_READ);
2652 ok( hFile != HFILE_ERROR, "OpenFile failed on read\n" );
2653 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2654 "GetLastError() returns %d\n", GetLastError() );
2655 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2656 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2657 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2658 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2659 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2660 ret = _lclose(hFile);
2661 ok( !ret, "_lclose() returns %d\n", ret );
2662
2663 memset(&ofs, 0xA5, sizeof(ofs));
2664 SetLastError(0xfaceabee);
2665 /* for writing only, */
2666 hFile = OpenFile(filename, &ofs, OF_WRITE);
2667 ok( hFile != HFILE_ERROR, "OpenFile failed on write\n" );
2668 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2669 "GetLastError() returns %d\n", GetLastError() );
2670 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2671 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2672 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2673 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2674 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2675 ret = _lclose(hFile);
2676 ok( !ret, "_lclose() returns %d\n", ret );
2677
2678 memset(&ofs, 0xA5, sizeof(ofs));
2679 SetLastError(0xfaceabee);
2680 /* for reading and writing, */
2681 hFile = OpenFile(filename, &ofs, OF_READWRITE);
2682 ok( hFile != HFILE_ERROR, "OpenFile failed on read/write\n" );
2683 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2684 "GetLastError() returns %d\n", GetLastError() );
2685 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2686 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2687 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2688 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2689 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2690 ret = _lclose(hFile);
2691 ok( !ret, "_lclose() returns %d\n", ret );
2692
2693 memset(&ofs, 0xA5, sizeof(ofs));
2694 SetLastError(0xfaceabee);
2695 /* for checking file presence. */
2696 hFile = OpenFile(filename, &ofs, OF_EXIST);
2697 ok( hFile == 1, "OpenFile failed on finding our created file\n" );
2698 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2699 "GetLastError() returns %d\n", GetLastError() );
2700 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2701 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2702 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2703 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2704 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2705
2706 memset(&ofs, 0xA5, sizeof(ofs));
2707 SetLastError(0xfaceabee);
2708 /* Delete the file and make sure it doesn't exist anymore */
2709 hFile = OpenFile(filename, &ofs, OF_DELETE);
2710 ok( hFile == 1, "OpenFile failed on delete (%d)\n", hFile );
2711 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
2712 "GetLastError() returns %d\n", GetLastError() );
2713 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
2714 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
2715 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
2716 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
2717 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
2718
2719 retval = GetFileAttributesA(filename);
2720 ok( retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file\n" );
2721 }
2722
2723 static void test_overlapped(void)
2724 {
2725 OVERLAPPED ov;
2726 DWORD r, result;
2727
2728 /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
2729 if (0) /* tested: WinXP */
2730 {
2731 GetOverlappedResult(0, NULL, &result, FALSE);
2732 GetOverlappedResult(0, &ov, NULL, FALSE);
2733 GetOverlappedResult(0, NULL, NULL, FALSE);
2734 }
2735
2736 memset( &ov, 0, sizeof ov );
2737 result = 1;
2738 r = GetOverlappedResult(0, &ov, &result, 0);
2739 if (r)
2740 ok( result == 0, "wrong result %u\n", result );
2741 else /* win9x */
2742 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2743
2744 result = 0;
2745 ov.Internal = 0;
2746 ov.InternalHigh = 0xabcd;
2747 r = GetOverlappedResult(0, &ov, &result, 0);
2748 if (r)
2749 ok( result == 0xabcd, "wrong result %u\n", result );
2750 else /* win9x */
2751 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2752
2753 SetLastError( 0xb00 );
2754 result = 0;
2755 ov.Internal = STATUS_INVALID_HANDLE;
2756 ov.InternalHigh = 0xabcd;
2757 r = GetOverlappedResult(0, &ov, &result, 0);
2758 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
2759 ok( r == FALSE, "should return false\n");
2760 ok( result == 0xabcd || result == 0 /* win9x */, "wrong result %u\n", result );
2761
2762 SetLastError( 0xb00 );
2763 result = 0;
2764 ov.Internal = STATUS_PENDING;
2765 ov.InternalHigh = 0xabcd;
2766 r = GetOverlappedResult(0, &ov, &result, 0);
2767 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2768 "wrong error %u\n", GetLastError() );
2769 ok( r == FALSE, "should return false\n");
2770 ok( result == 0, "wrong result %u\n", result );
2771
2772 SetLastError( 0xb00 );
2773 ov.hEvent = CreateEvent( NULL, 1, 1, NULL );
2774 ov.Internal = STATUS_PENDING;
2775 ov.InternalHigh = 0xabcd;
2776 r = GetOverlappedResult(0, &ov, &result, 0);
2777 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2778 "wrong error %u\n", GetLastError() );
2779 ok( r == FALSE, "should return false\n");
2780
2781 ResetEvent( ov.hEvent );
2782
2783 SetLastError( 0xb00 );
2784 ov.Internal = STATUS_PENDING;
2785 ov.InternalHigh = 0;
2786 r = GetOverlappedResult(0, &ov, &result, 0);
2787 ok( GetLastError() == ERROR_IO_INCOMPLETE || GetLastError() == ERROR_INVALID_HANDLE /* win9x */,
2788 "wrong error %u\n", GetLastError() );
2789 ok( r == FALSE, "should return false\n");
2790
2791 r = CloseHandle( ov.hEvent );
2792 ok( r == TRUE, "close handle failed\n");
2793 }
2794
2795 static void test_RemoveDirectory(void)
2796 {
2797 int rc;
2798 char directory[] = "removeme";
2799
2800 rc = CreateDirectory(directory, NULL);
2801 ok( rc, "Createdirectory failed, gle=%d\n", GetLastError() );
2802
2803 rc = SetCurrentDirectory(directory);
2804 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2805
2806 rc = RemoveDirectory(".");
2807 if (!rc)
2808 {
2809 rc = SetCurrentDirectory("..");
2810 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2811
2812 rc = RemoveDirectory(directory);
2813 ok( rc, "RemoveDirectory failed, gle=%d\n", GetLastError() );
2814 }
2815 }
2816
2817 static BOOL check_file_time( const FILETIME *ft1, const FILETIME *ft2, UINT tolerance )
2818 {
2819 ULONGLONG t1 = ((ULONGLONG)ft1->dwHighDateTime << 32) | ft1->dwLowDateTime;
2820 ULONGLONG t2 = ((ULONGLONG)ft2->dwHighDateTime << 32) | ft2->dwLowDateTime;
2821 return abs(t1 - t2) <= tolerance;
2822 }
2823
2824 static void test_ReplaceFileA(void)
2825 {
2826 char replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
2827 HANDLE hReplacedFile, hReplacementFile, hBackupFile;
2828 static const char replacedData[] = "file-to-replace";
2829 static const char replacementData[] = "new-file";
2830 static const char backupData[] = "backup-file";
2831 FILETIME ftReplaced, ftReplacement, ftBackup;
2832 static const char prefix[] = "pfx";
2833 char temp_path[MAX_PATH];
2834 DWORD ret;
2835 BOOL retok, removeBackup = FALSE;
2836
2837 if (!pReplaceFileA)
2838 {
2839 win_skip("ReplaceFileA() is missing\n");
2840 return;
2841 }
2842
2843 ret = GetTempPathA(MAX_PATH, temp_path);
2844 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
2845 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
2846
2847 ret = GetTempFileNameA(temp_path, prefix, 0, replaced);
2848 ok(ret != 0, "GetTempFileNameA error (replaced) %d\n", GetLastError());
2849
2850 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2851 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2852
2853 ret = GetTempFileNameA(temp_path, prefix, 0, backup);
2854 ok(ret != 0, "GetTempFileNameA error (backup) %d\n", GetLastError());
2855
2856 /* place predictable data in the file to be replaced */
2857 hReplacedFile = CreateFileA(replaced, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2858 ok(hReplacedFile != INVALID_HANDLE_VALUE,
2859 "failed to open replaced file\n");
2860 retok = WriteFile(hReplacedFile, replacedData, sizeof(replacedData), &ret, NULL );
2861 ok( retok && ret == sizeof(replacedData),
2862 "WriteFile error (replaced) %d\n", GetLastError());
2863 ok(GetFileSize(hReplacedFile, NULL) == sizeof(replacedData),
2864 "replaced file has wrong size\n");
2865 /* place predictable data in the file to be the replacement */
2866 hReplacementFile = CreateFileA(replacement, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2867 ok(hReplacementFile != INVALID_HANDLE_VALUE,
2868 "failed to open replacement file\n");
2869 retok = WriteFile(hReplacementFile, replacementData, sizeof(replacementData), &ret, NULL );
2870 ok( retok && ret == sizeof(replacementData),
2871 "WriteFile error (replacement) %d\n", GetLastError());
2872 ok(GetFileSize(hReplacementFile, NULL) == sizeof(replacementData),
2873 "replacement file has wrong size\n");
2874 /* place predictable data in the backup file (to be over-written) */
2875 hBackupFile = CreateFileA(backup, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
2876 ok(hBackupFile != INVALID_HANDLE_VALUE,
2877 "failed to open backup file\n");
2878 retok = WriteFile(hBackupFile, backupData, sizeof(backupData), &ret, NULL );
2879 ok( retok && ret == sizeof(backupData),
2880 "WriteFile error (replacement) %d\n", GetLastError());
2881 ok(GetFileSize(hBackupFile, NULL) == sizeof(backupData),
2882 "backup file has wrong size\n");
2883 /* change the filetime on the "replaced" file to ensure that it changes */
2884 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2885 ok( ret, "GetFileTime error (replaced) %d\n", GetLastError());
2886 ftReplaced.dwLowDateTime -= 600000000; /* 60 second */
2887 ret = SetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2888 ok( ret, "SetFileTime error (replaced) %d\n", GetLastError());
2889 GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced); /* get the actual time back */
2890 CloseHandle(hReplacedFile);
2891 /* change the filetime on the backup to ensure that it changes */
2892 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2893 ok( ret, "GetFileTime error (backup) %d\n", GetLastError());
2894 ftBackup.dwLowDateTime -= 1200000000; /* 120 second */
2895 ret = SetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2896 ok( ret, "SetFileTime error (backup) %d\n", GetLastError());
2897 GetFileTime(hBackupFile, NULL, NULL, &ftBackup); /* get the actual time back */
2898 CloseHandle(hBackupFile);
2899 /* get the filetime on the replacement file to perform checks */
2900 ret = GetFileTime(hReplacementFile, NULL, NULL, &ftReplacement);
2901 ok( ret, "GetFileTime error (replacement) %d\n", GetLastError());
2902 CloseHandle(hReplacementFile);
2903
2904 /* perform replacement w/ backup
2905 * TODO: flags are not implemented
2906 */
2907 SetLastError(0xdeadbeef);
2908 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
2909 ok(ret, "ReplaceFileA: unexpected error %d\n", GetLastError());
2910 /* make sure that the backup has the size of the old "replaced" file */
2911 hBackupFile = CreateFileA(backup, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2912 ok(hBackupFile != INVALID_HANDLE_VALUE,
2913 "failed to open backup file\n");
2914 ret = GetFileSize(hBackupFile, NULL);
2915 ok(ret == sizeof(replacedData),
2916 "backup file has wrong size %d\n", ret);
2917 /* make sure that the "replaced" file has the size of the replacement file */
2918 hReplacedFile = CreateFileA(replaced, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2919 ok(hReplacedFile != INVALID_HANDLE_VALUE,
2920 "failed to open replaced file: %d\n", GetLastError());
2921 if (hReplacedFile != INVALID_HANDLE_VALUE)
2922 {
2923 ret = GetFileSize(hReplacedFile, NULL);
2924 ok(ret == sizeof(replacementData),
2925 "replaced file has wrong size %d\n", ret);
2926 /* make sure that the replacement file no-longer exists */
2927 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2928 ok(hReplacementFile == INVALID_HANDLE_VALUE,
2929 "unexpected error, replacement file should not exist %d\n", GetLastError());
2930 /* make sure that the backup has the old "replaced" filetime */
2931 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
2932 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
2933 ok(check_file_time(&ftBackup, &ftReplaced, 20000000), "backup file has wrong filetime\n");
2934 CloseHandle(hBackupFile);
2935 /* make sure that the "replaced" has the old replacement filetime */
2936 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
2937 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
2938 ok(check_file_time(&ftReplaced, &ftReplacement, 20000000),
2939 "replaced file has wrong filetime %x%08x / %x%08x\n",
2940 ftReplaced.dwHighDateTime, ftReplaced.dwLowDateTime,
2941 ftReplacement.dwHighDateTime, ftReplacement.dwLowDateTime );
2942 CloseHandle(hReplacedFile);
2943 }
2944 else
2945 skip("couldn't open replacement file, skipping tests\n");
2946
2947 /* re-create replacement file for pass w/o backup (blank) */
2948 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2949 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2950 /* perform replacement w/o backup
2951 * TODO: flags are not implemented
2952 */
2953 SetLastError(0xdeadbeef);
2954 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
2955 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2956 "ReplaceFileA: unexpected error %d\n", GetLastError());
2957
2958 /* re-create replacement file for pass w/ backup (backup-file not existing) */
2959 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2960 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2961 ret = DeleteFileA(backup);
2962 ok(ret, "DeleteFileA: error (backup) %d\n", GetLastError());
2963 /* perform replacement w/ backup (no pre-existing backup)
2964 * TODO: flags are not implemented
2965 */
2966 SetLastError(0xdeadbeef);
2967 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
2968 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2969 "ReplaceFileA: unexpected error %d\n", GetLastError());
2970 if (ret)
2971 removeBackup = TRUE;
2972
2973 /* re-create replacement file for pass w/ no permissions to "replaced" */
2974 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
2975 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2976 ret = SetFileAttributesA(replaced, FILE_ATTRIBUTE_READONLY);
2977 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2978 "SetFileAttributesA: error setting to read only %d\n", GetLastError());
2979 /* perform replacement w/ backup (no permission to "replaced")
2980 * TODO: flags are not implemented
2981 */
2982 SetLastError(0xdeadbeef);
2983 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
2984 ok(ret != ERROR_UNABLE_TO_REMOVE_REPLACED, "ReplaceFileA: unexpected error %d\n", GetLastError());
2985 /* make sure that the replacement file still exists */
2986 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2987 ok(hReplacementFile != INVALID_HANDLE_VALUE ||
2988 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* win2k */
2989 "unexpected error, replacement file should still exist %d\n", GetLastError());
2990 CloseHandle(hReplacementFile);
2991 ret = SetFileAttributesA(replaced, FILE_ATTRIBUTE_NORMAL);
2992 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2993 "SetFileAttributesA: error setting to normal %d\n", GetLastError());
2994
2995 /* replacement file still exists, make pass w/o "replaced" */
2996 ret = DeleteFileA(replaced);
2997 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
2998 "DeleteFileA: error (replaced) %d\n", GetLastError());
2999 /* perform replacement w/ backup (no pre-existing backup or "replaced")
3000 * TODO: flags are not implemented
3001 */
3002 SetLastError(0xdeadbeef);
3003 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3004 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3005 GetLastError() == ERROR_ACCESS_DENIED),
3006 "ReplaceFileA: unexpected error %d\n", GetLastError());
3007
3008 /* perform replacement w/o existing "replacement" file
3009 * TODO: flags are not implemented
3010 */
3011 SetLastError(0xdeadbeef);
3012 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
3013 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3014 GetLastError() == ERROR_ACCESS_DENIED),
3015 "ReplaceFileA: unexpected error %d\n", GetLastError());
3016
3017 /*
3018 * if the first round (w/ backup) worked then as long as there is no
3019 * failure then there is no need to check this round (w/ backup is the
3020 * more complete case)
3021 */
3022
3023 /* delete temporary files, replacement and replaced are already deleted */
3024 if (removeBackup)
3025 {
3026 ret = DeleteFileA(backup);
3027 ok(ret ||
3028 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3029 "DeleteFileA: error (backup) %d\n", GetLastError());
3030 }
3031 }
3032
3033 /*
3034 * ReplaceFileW is a simpler case of ReplaceFileA, there is no
3035 * need to be as thorough.
3036 */
3037 static void test_ReplaceFileW(void)
3038 {
3039 WCHAR replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
3040 static const WCHAR prefix[] = {'p','f','x',0};
3041 WCHAR temp_path[MAX_PATH];
3042 DWORD ret;
3043 BOOL removeBackup = FALSE;
3044
3045 if (!pReplaceFileW)
3046 {
3047 win_skip("ReplaceFileW() is missing\n");
3048 return;
3049 }
3050
3051 ret = GetTempPathW(MAX_PATH, temp_path);
3052 if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3053 {
3054 win_skip("GetTempPathW is not available\n");
3055 return;
3056 }
3057 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
3058 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
3059
3060 ret = GetTempFileNameW(temp_path, prefix, 0, replaced);
3061 ok(ret != 0, "GetTempFileNameW error (replaced) %d\n", GetLastError());
3062
3063 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3064 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3065
3066 ret = GetTempFileNameW(temp_path, prefix, 0, backup);
3067 ok(ret != 0, "GetTempFileNameW error (backup) %d\n", GetLastError());
3068
3069 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3070 ok(ret, "ReplaceFileW: error %d\n", GetLastError());
3071
3072 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3073 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3074 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3075 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3076 "ReplaceFileW: error %d\n", GetLastError());
3077
3078 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3079 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3080 ret = DeleteFileW(backup);
3081 ok(ret, "DeleteFileW: error (backup) %d\n", GetLastError());
3082 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3083 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3084 "ReplaceFileW: error %d\n", GetLastError());
3085
3086 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3087 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3088 ret = SetFileAttributesW(replaced, FILE_ATTRIBUTE_READONLY);
3089 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3090 "SetFileAttributesW: error setting to read only %d\n", GetLastError());
3091
3092 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3093 ok(ret != ERROR_UNABLE_TO_REMOVE_REPLACED,
3094 "ReplaceFileW: unexpected error %d\n", GetLastError());
3095 ret = SetFileAttributesW(replaced, FILE_ATTRIBUTE_NORMAL);
3096 ok(ret || GetLastError() == ERROR_ACCESS_DENIED,
3097 "SetFileAttributesW: error setting to normal %d\n", GetLastError());
3098 if (ret)
3099 removeBackup = TRUE;
3100
3101 ret = DeleteFileW(replaced);
3102 ok(ret, "DeleteFileW: error (replaced) %d\n", GetLastError());
3103 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3104 ok(!ret, "ReplaceFileW: error %d\n", GetLastError());
3105
3106 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3107 ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
3108 GetLastError() == ERROR_ACCESS_DENIED),
3109 "ReplaceFileW: unexpected error %d\n", GetLastError());
3110
3111 if (removeBackup)
3112 {
3113 ret = DeleteFileW(backup);
3114 ok(ret ||
3115 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3116 "DeleteFileW: error (backup) %d\n", GetLastError());
3117 }
3118 }
3119
3120 START_TEST(file)
3121 {
3122 InitFunctionPointers();
3123
3124 test__hread( );
3125 test__hwrite( );
3126 test__lclose( );
3127 test__lcreat( );
3128 test__llseek( );
3129 test__llopen( );
3130 test__lread( );
3131 test__lwrite( );
3132 test_GetTempFileNameA();
3133 test_CopyFileA();
3134 test_CopyFileW();
3135 test_CreateFileA();
3136 test_CreateFileW();
3137 test_DeleteFileA();
3138 test_DeleteFileW();
3139 test_MoveFileA();
3140 test_MoveFileW();
3141 test_FindFirstFileA();
3142 test_FindNextFileA();
3143 test_FindFirstFileExA(0);
3144 /* FindExLimitToDirectories is ignored if the file system doesn't support directory filtering */
3145 test_FindFirstFileExA(FindExSearchLimitToDirectories);
3146 test_LockFile();
3147 test_file_sharing();
3148 test_offset_in_overlapped_structure();
3149 test_MapFile();
3150 test_GetFileType();
3151 test_async_file_errors();
3152 test_read_write();
3153 test_OpenFile();
3154 test_overlapped();
3155 test_RemoveDirectory();
3156 test_ReplaceFileA();
3157 test_ReplaceFileW();
3158 }
Maarten's multimedia branch