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