2 * Unit tests for file functions in Wine
4 * Copyright (c) 2002, 2004 Jakob Eriksson
5 * Copyright (c) 2008 Jeff Zaroyko
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.
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.
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
23 /* ReplaceFile requires Windows 2000 or newer */
24 #define _WIN32_WINNT 0x0500
31 #include "wine/test.h"
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
);
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 ";
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 */
66 static void InitFunctionPointers(void)
68 HMODULE hkernel32
= GetModuleHandleA("kernel32");
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");
78 static void test__hread( void )
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
)
92 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
96 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
98 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
100 filehandle
= _lopen( filename
, OF_READ
);
102 ok( HFILE_ERROR
!= filehandle
, "couldn't open file \"%s\" again (err=%d)\n", filename
, GetLastError( ) );
104 bytes_read
= _hread( filehandle
, buffer
, 2 * strlen( sillytext
) );
106 ok( lstrlenA( sillytext
) == bytes_read
, "file read size error\n" );
108 for (bytes_wanted
= 0; bytes_wanted
< lstrlenA( sillytext
); bytes_wanted
++)
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
++)
114 ok( buffer
[i
] == sillytext
[i
], "that's not what's written\n" );
118 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
120 ret
= DeleteFileA( filename
);
121 ok( ret
!= 0, "DeleteFile failed (%d)\n", GetLastError( ) );
125 static void test__hwrite( void )
134 HLOCAL memory_object
;
138 filehandle
= _lcreat( filename
, 0 );
139 if (filehandle
== HFILE_ERROR
)
141 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
145 ok( HFILE_ERROR
!= _hwrite( filehandle
, "", 0 ), "_hwrite complains\n" );
147 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
149 filehandle
= _lopen( filename
, OF_READ
);
151 bytes_read
= _hread( filehandle
, buffer
, 1);
153 ok( 0 == bytes_read
, "file read size error\n" );
155 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
157 filehandle
= _lopen( filename
, OF_READWRITE
);
161 srand( (unsigned)time( NULL
) );
162 for (blocks
= 0; blocks
< 100; blocks
++)
164 for (i
= 0; i
< (LONG
)sizeof( buffer
); i
++)
167 checksum
[0] = checksum
[0] + buffer
[i
];
169 ok( HFILE_ERROR
!= _hwrite( filehandle
, buffer
, sizeof( buffer
) ), "_hwrite complains\n" );
170 bytes_written
= bytes_written
+ sizeof( buffer
);
173 ok( HFILE_ERROR
!= _hwrite( filehandle
, checksum
, 1 ), "_hwrite complains\n" );
176 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
178 memory_object
= LocalAlloc( LPTR
, bytes_written
);
180 ok( 0 != memory_object
, "LocalAlloc fails. (Could be out of memory.)\n" );
182 contents
= LocalLock( memory_object
);
183 ok( NULL
!= contents
, "LocalLock whines\n" );
185 filehandle
= _lopen( filename
, OF_READ
);
187 contents
= LocalLock( memory_object
);
188 ok( NULL
!= contents
, "LocalLock whines\n" );
190 ok( bytes_written
== _hread( filehandle
, contents
, bytes_written
), "read length differ from write length\n" );
196 checksum
[0] = checksum
[0] + contents
[i
];
199 while (i
< bytes_written
- 1);
201 ok( checksum
[0] == contents
[i
], "stored checksum differ from computed checksum\n" );
203 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
205 ret
= DeleteFileA( filename
);
206 ok( ret
!= 0, "DeleteFile failed (%d)\n", GetLastError( ) );
208 LocalFree( contents
);
212 static void test__lclose( void )
217 filehandle
= _lcreat( filename
, 0 );
218 if (filehandle
== HFILE_ERROR
)
220 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
224 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
226 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
228 ret
= DeleteFileA( filename
);
229 ok( ret
!= 0, "DeleteFile failed (%d)\n", GetLastError( ) );
233 static void test__lcreat( void )
237 WIN32_FIND_DATAA search_results
;
238 char slashname
[] = "testfi/";
243 filehandle
= _lcreat( filename
, 0 );
244 if (filehandle
== HFILE_ERROR
)
246 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
250 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
252 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
254 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
256 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
258 find
= FindFirstFileA( filename
, &search_results
);
259 ok( INVALID_HANDLE_VALUE
!= find
, "should be able to find file\n" );
262 ret
= DeleteFileA(filename
);
263 ok( ret
!= 0, "DeleteFile failed (%d)\n", GetLastError());
265 filehandle
= _lcreat( filename
, 1 ); /* readonly */
266 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%d)\n", filename
, GetLastError( ) );
268 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite shouldn't be able to write never the less\n" );
270 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
272 find
= FindFirstFileA( filename
, &search_results
);
273 ok( INVALID_HANDLE_VALUE
!= find
, "should be able to find file\n" );
276 ok( 0 == DeleteFileA( filename
), "shouldn't be able to delete a readonly file\n" );
278 ok( SetFileAttributesA(filename
, FILE_ATTRIBUTE_NORMAL
) != 0, "couldn't change attributes on file\n" );
280 ok( DeleteFileA( filename
) != 0, "now it should be possible to delete the file!\n" );
282 filehandle
= _lcreat( filename
, 2 );
283 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%d)\n", filename
, GetLastError( ) );
285 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
287 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
289 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
291 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
293 find
= FindFirstFileA( filename
, &search_results
);
294 ok( INVALID_HANDLE_VALUE
!= find
, "should STILL be able to find file\n" );
297 ret
= DeleteFileA( filename
);
298 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
300 filehandle
= _lcreat( filename
, 4 ); /* SYSTEM file */
301 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%d)\n", filename
, GetLastError( ) );
303 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
305 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
307 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
309 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
311 find
= FindFirstFileA( filename
, &search_results
);
312 ok( INVALID_HANDLE_VALUE
!= find
, "should STILL be able to find file\n" );
315 ret
= DeleteFileA( filename
);
316 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
318 filehandle
=_lcreat (slashname
, 0); /* illegal name */
319 if (HFILE_ERROR
==filehandle
) {
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 */
325 find
=FindFirstFileA (slashname
, &search_results
);
326 if (INVALID_HANDLE_VALUE
!=find
)
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
);
337 ret
= DeleteFileA( slashname
);
338 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
341 filehandle
=_lcreat (filename
, 8); /* illegal attribute */
342 if (HFILE_ERROR
==filehandle
)
343 ok (0, "couldn't create volume label \"%s\"\n", filename
);
346 find
=FindFirstFileA (filename
, &search_results
);
347 if (INVALID_HANDLE_VALUE
==find
)
348 ok (0, "file \"%s\" not found\n", filename
);
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
);
359 ret
= DeleteFileA( filename
);
360 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
365 static void test__llseek( void )
373 filehandle
= _lcreat( filename
, 0 );
374 if (filehandle
== HFILE_ERROR
)
376 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
380 for (i
= 0; i
< 400; i
++)
382 ok( _hwrite( filehandle
, sillytext
, strlen( sillytext
) ) != -1, "_hwrite complains\n" );
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" );
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" );
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" );
398 ret
= DeleteFileA( filename
);
399 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
403 static void test__llopen( void )
410 filehandle
= _lcreat( filename
, 0 );
411 if (filehandle
== HFILE_ERROR
)
413 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
417 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
418 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
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" );
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" );
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" );
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 */
443 static void test__lread( void )
452 filehandle
= _lcreat( filename
, 0 );
453 if (filehandle
== HFILE_ERROR
)
455 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
459 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
461 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
463 filehandle
= _lopen( filename
, OF_READ
);
465 ok( HFILE_ERROR
!= filehandle
, "couldn't open file \"%s\" again (err=%d)\n", filename
, GetLastError());
467 bytes_read
= _lread( filehandle
, buffer
, 2 * strlen( sillytext
) );
469 ok( lstrlenA( sillytext
) == bytes_read
, "file read size error\n" );
471 for (bytes_wanted
= 0; bytes_wanted
< strlen( sillytext
); bytes_wanted
++)
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
++)
477 ok( buffer
[i
] == sillytext
[i
], "that's not what's written\n" );
481 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
483 ret
= DeleteFileA( filename
);
484 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
488 static void test__lwrite( void )
497 HLOCAL memory_object
;
501 filehandle
= _lcreat( filename
, 0 );
502 if (filehandle
== HFILE_ERROR
)
504 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
508 ok( HFILE_ERROR
!= _lwrite( filehandle
, "", 0 ), "_hwrite complains\n" );
510 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
512 filehandle
= _lopen( filename
, OF_READ
);
514 bytes_read
= _hread( filehandle
, buffer
, 1);
516 ok( 0 == bytes_read
, "file read size error\n" );
518 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
520 filehandle
= _lopen( filename
, OF_READWRITE
);
524 srand( (unsigned)time( NULL
) );
525 for (blocks
= 0; blocks
< 100; blocks
++)
527 for (i
= 0; i
< (INT
)sizeof( buffer
); i
++)
530 checksum
[0] = checksum
[0] + buffer
[i
];
532 ok( HFILE_ERROR
!= _lwrite( filehandle
, buffer
, sizeof( buffer
) ), "_hwrite complains\n" );
533 bytes_written
= bytes_written
+ sizeof( buffer
);
536 ok( HFILE_ERROR
!= _lwrite( filehandle
, checksum
, 1 ), "_hwrite complains\n" );
539 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
541 memory_object
= LocalAlloc( LPTR
, bytes_written
);
543 ok( 0 != memory_object
, "LocalAlloc fails, could be out of memory\n" );
545 contents
= LocalLock( memory_object
);
546 ok( NULL
!= contents
, "LocalLock whines\n" );
548 filehandle
= _lopen( filename
, OF_READ
);
550 contents
= LocalLock( memory_object
);
551 ok( NULL
!= contents
, "LocalLock whines\n" );
553 ok( bytes_written
== _hread( filehandle
, contents
, bytes_written
), "read length differ from write length\n" );
559 checksum
[0] += contents
[i
];
562 while (i
< bytes_written
- 1);
564 ok( checksum
[0] == contents
[i
], "stored checksum differ from computed checksum\n" );
566 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
568 ret
= DeleteFileA( filename
);
569 ok( ret
, "DeleteFile failed (%d)\n", GetLastError( ) );
571 LocalFree( contents
);
574 static void test_CopyFileA(void)
576 char temp_path
[MAX_PATH
];
577 char source
[MAX_PATH
], dest
[MAX_PATH
];
578 static const char prefix
[] = "pfx";
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");
590 ret
= GetTempFileNameA(temp_path
, prefix
, 0, source
);
591 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
593 ret
= MoveFileA(source
, source
);
594 todo_wine
ok(ret
, "MoveFileA: failed, error %d\n", GetLastError());
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());
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 */
617 ret
= GetTempFileNameA(temp_path
, prefix
, 0, dest
);
618 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
620 SetLastError(0xdeadbeef);
621 ret
= CopyFileA(source
, dest
, TRUE
);
622 ok(!ret
&& GetLastError() == ERROR_FILE_EXISTS
,
623 "CopyFileA: unexpected error %d\n", GetLastError());
625 ret
= CopyFileA(source
, dest
, FALSE
);
626 ok(ret
, "CopyFileA: error %d\n", GetLastError());
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());
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
);
645 "copying from an r+w opened and r shared file failed (ret=%d, err=%d)\n", retok
, GetLastError());
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());
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());
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());
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
)
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());
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());
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
);
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");
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());
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");
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());
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());
724 CloseHandle(hmapfile
);
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");
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());
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());
740 CloseHandle(hmapfile
);
743 ret
= DeleteFileA(source
);
744 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
745 ret
= DeleteFileA(dest
);
746 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
749 static void test_CopyFileW(void)
751 WCHAR temp_path
[MAX_PATH
];
752 WCHAR source
[MAX_PATH
], dest
[MAX_PATH
];
753 static const WCHAR prefix
[] = {'p','f','x',0};
756 ret
= GetTempPathW(MAX_PATH
, temp_path
);
757 if (ret
== 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
759 win_skip("GetTempPathW is not available\n");
762 ok(ret
!= 0, "GetTempPathW error %d\n", GetLastError());
763 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
765 ret
= GetTempFileNameW(temp_path
, prefix
, 0, source
);
766 ok(ret
!= 0, "GetTempFileNameW error %d\n", GetLastError());
768 ret
= GetTempFileNameW(temp_path
, prefix
, 0, dest
);
769 ok(ret
!= 0, "GetTempFileNameW error %d\n", GetLastError());
771 ret
= CopyFileW(source
, dest
, TRUE
);
772 ok(!ret
&& GetLastError() == ERROR_FILE_EXISTS
,
773 "CopyFileW: unexpected error %d\n", GetLastError());
775 ret
= CopyFileW(source
, dest
, FALSE
);
776 ok(ret
, "CopyFileW: error %d\n", GetLastError());
778 ret
= DeleteFileW(source
);
779 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
780 ret
= DeleteFileW(dest
);
781 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
786 * Debugging routine to dump a buffer in a hexdump-like fashion.
788 static void dumpmem(unsigned char *mem
, int len
)
799 p
+= sprintf(p
, "%02hhx ", mem
[x
]);
800 *c
++ = (mem
[x
] >= 32 && mem
[x
] <= 127) ? mem
[x
] : '.';
801 } while (++x
% 16 && x
< len
);
803 trace("%04x: %-48s- %s\n", x
, hex
, txt
);
807 static void test_CreateFileA(void)
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:";
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
}
834 BY_HANDLE_FILE_INFORMATION Finfo
;
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");
840 ret
= GetTempFileNameA(temp_path
, prefix
, 0, filename
);
841 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
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");
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());
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());
865 ret
= DeleteFileA(filename
);
866 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
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());
876 ret
= DeleteFileA(filename
);
877 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
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());
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());
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
);
904 /* update the drive id in the table entry with the current one */
905 if (p
[i
].file
[1] == ':')
907 strcpy(filename
, p
[i
].file
);
908 filename
[0] = windowsdir
[0];
910 else if (p
[i
].file
[0] == '\\' && p
[i
].file
[5] == ':')
912 strcpy(filename
, p
[i
].file
);
913 filename
[4] = windowsdir
[0];
917 /* prefix the table entry with the current temp directory */
918 strcpy(filename
, temp_path
);
919 strcat(filename
, p
[i
].file
);
921 hFile
= CreateFileA( filename
, GENERIC_READ
| GENERIC_WRITE
,
922 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
924 p
[i
].options
, NULL
);
925 /* if we get ACCESS_DENIED when we do not expect it, assume
926 * no access to the volume
928 if (hFile
== INVALID_HANDLE_VALUE
&&
929 GetLastError() == ERROR_ACCESS_DENIED
&&
930 p
[i
].err
!= ERROR_ACCESS_DENIED
)
933 skip("Either no authority to volume, or is todo_wine for %s err=%d should be %d\n", filename
, GetLastError(), p
[i
].err
);
935 skip("Do not have authority to access volumes. Test for %s skipped\n", filename
);
937 /* otherwise validate results with expectations */
938 else if (p
[i
].todo_flag
)
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
);
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
);
956 ret
= RemoveDirectoryA(dirname
);
957 ok(ret
, "RemoveDirectoryA: error %d\n", GetLastError());
960 /* test opening directory as a directory */
961 hFile
= CreateFileA( temp_path
, GENERIC_READ
,
965 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
966 if (hFile
!= INVALID_HANDLE_VALUE
&& GetLastError() != ERROR_PATH_NOT_FOUND
)
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
);
972 if (hFile
!= INVALID_HANDLE_VALUE
)
974 ret
= GetFileInformationByHandle( hFile
, &Finfo
);
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
);
981 CloseHandle( hFile
);
985 skip("Probable Win9x, got ERROR_PATH_NOT_FOUND w/ FILE_FLAG_BACKUP_SEMANTICS or %s\n", temp_path
);
988 /* *** Test opening volumes/devices using drive letter *** */
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
,
997 FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_NO_BUFFERING
, NULL
);
998 if (hFile
!= INVALID_HANDLE_VALUE
||
999 (GetLastError() != ERROR_ACCESS_DENIED
&& GetLastError() != ERROR_BAD_NETPATH
))
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
)
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. */
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
);
1015 trace("buffer is\n");
1016 dumpmem(buffer
, 64);
1018 CloseHandle( hFile
);
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
);
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
);
1037 /* test using temp path with trailing \ and in non-rewrite as dir */
1038 /* this should work */
1039 strcpy(filename
, nt_drive
);
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
);
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];
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
);
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");
1070 skip("Do not have authority to access volumes. Tests skipped\n");
1073 /* *** Test opening volumes/devices using GUID *** */
1075 if (pGetVolumeNameForVolumeMountPointA
)
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());
1083 ok(strlen(Volume_1
) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name <%s>\n", Volume_1
);
1085 /* test the result of opening a unique volume name (GUID)
1086 * with the trailing \
1087 * this should error out
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
);
1095 ok(hFile
== INVALID_HANDLE_VALUE
,
1096 "CreateFileA should not have opened %s, hFile %p\n",
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
);
1105 /* test the result of opening a unique volume name (GUID)
1106 * with the temp path string as dir
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
);
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
);
1122 /* test the result of opening a unique volume name (GUID)
1123 * without the trailing \ and in device namespace
1126 strcpy(filename
, Volume_1
);
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
)
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
)
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. */
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
);
1149 trace("buffer is\n");
1150 dumpmem(buffer
, 64);
1152 CloseHandle( hFile
);
1156 skip("Do not have authority to access volumes. Tests skipped\n");
1159 win_skip("GetVolumeNameForVolumeMountPointA not functioning\n");
1162 win_skip("GetVolumeNameForVolumeMountPointA not found\n");
1165 static void test_CreateFileW(void)
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 };
1175 ret
= GetTempPathW(MAX_PATH
, temp_path
);
1176 if (ret
== 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1178 win_skip("GetTempPathW is not available\n");
1181 ok(ret
!= 0, "GetTempPathW error %d\n", GetLastError());
1182 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
1184 ret
= GetTempFileNameW(temp_path
, prefix
, 0, filename
);
1185 ok(ret
!= 0, "GetTempFileNameW error %d\n", GetLastError());
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");
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());
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());
1209 ret
= DeleteFileW(filename
);
1210 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
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());
1220 ret
= DeleteFileW(filename
);
1221 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
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());
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());
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());
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());
1250 ret
= RemoveDirectoryW(filename
);
1251 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
1254 static void test_GetTempFileNameA(void)
1258 char expected
[MAX_PATH
+ 10];
1259 char windowsdir
[MAX_PATH
+ 10];
1260 char windowsdrive
[3];
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());
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:\" */
1269 strcat(windowsdir
, "\\");
1272 windowsdrive
[0] = windowsdir
[0];
1273 windowsdrive
[1] = windowsdir
[1];
1274 windowsdrive
[2] = '\0';
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
);
1282 result
= GetTempFileNameA(windowsdir
, "abc", 2, out
);
1283 ok(result
!= 0, "GetTempFileNameA: error %d\n", GetLastError());
1285 strcat(expected
, windowsdir
);
1286 strcat(expected
, "abc2.tmp");
1287 ok(lstrcmpiA(out
, expected
) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
1291 static void test_DeleteFileA( void )
1295 ret
= DeleteFileA(NULL
);
1296 ok(!ret
&& (GetLastError() == ERROR_INVALID_PARAMETER
||
1297 GetLastError() == ERROR_PATH_NOT_FOUND
),
1298 "DeleteFileA(NULL) returned ret=%d error=%d\n",ret
,GetLastError());
1300 ret
= DeleteFileA("");
1301 ok(!ret
&& (GetLastError() == ERROR_PATH_NOT_FOUND
||
1302 GetLastError() == ERROR_BAD_PATHNAME
),
1303 "DeleteFileA(\"\") returned ret=%d error=%d\n",ret
,GetLastError());
1305 ret
= DeleteFileA("nul");
1306 ok(!ret
&& (GetLastError() == ERROR_FILE_NOT_FOUND
||
1307 GetLastError() == ERROR_INVALID_PARAMETER
||
1308 GetLastError() == ERROR_ACCESS_DENIED
||
1309 GetLastError() == ERROR_INVALID_FUNCTION
),
1310 "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret
,GetLastError());
1313 static void test_DeleteFileW( void )
1316 WCHAR pathW
[MAX_PATH
];
1317 WCHAR pathsubW
[MAX_PATH
];
1318 static const WCHAR dirW
[] = {'d','e','l','e','t','e','f','i','l','e',0};
1319 static const WCHAR subdirW
[] = {'\\','s','u','b',0};
1320 static const WCHAR emptyW
[]={'\0'};
1322 ret
= DeleteFileW(NULL
);
1323 if (ret
== 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1325 win_skip("DeleteFileW is not available\n");
1328 ok(!ret
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
1329 "DeleteFileW(NULL) returned ret=%d error=%d\n",ret
,GetLastError());
1331 ret
= DeleteFileW(emptyW
);
1332 ok(!ret
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
1333 "DeleteFileW(\"\") returned ret=%d error=%d\n",ret
,GetLastError());
1335 /* test DeleteFile on empty directory */
1336 ret
= GetTempPathW(MAX_PATH
, pathW
);
1337 if (ret
+ sizeof(dirW
)/sizeof(WCHAR
)-1 + sizeof(subdirW
)/sizeof(WCHAR
)-1 >= MAX_PATH
)
1339 ok(0, "MAX_PATH exceeded in constructing paths\n");
1342 lstrcatW(pathW
, dirW
);
1343 lstrcpyW(pathsubW
, pathW
);
1344 lstrcatW(pathsubW
, subdirW
);
1345 ret
= CreateDirectoryW(pathW
, NULL
);
1346 ok(ret
== TRUE
, "couldn't create directory deletefile\n");
1347 ret
= DeleteFileW(pathW
);
1348 ok(ret
== FALSE
, "DeleteFile should fail for empty directories\n");
1349 ret
= RemoveDirectoryW(pathW
);
1350 ok(ret
== TRUE
, "expected to remove directory deletefile\n");
1352 /* test DeleteFile on non-empty directory */
1353 ret
= CreateDirectoryW(pathW
, NULL
);
1354 ok(ret
== TRUE
, "couldn't create directory deletefile\n");
1355 ret
= CreateDirectoryW(pathsubW
, NULL
);
1356 ok(ret
== TRUE
, "couldn't create directory deletefile\\sub\n");
1357 ret
= DeleteFileW(pathW
);
1358 ok(ret
== FALSE
, "DeleteFile should fail for non-empty directories\n");
1359 ret
= RemoveDirectoryW(pathsubW
);
1360 ok(ret
== TRUE
, "expected to remove directory deletefile\\sub\n");
1361 ret
= RemoveDirectoryW(pathW
);
1362 ok(ret
== TRUE
, "expected to remove directory deletefile\n");
1365 #define IsDotDir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
1367 static void test_MoveFileA(void)
1369 char tempdir
[MAX_PATH
];
1370 char source
[MAX_PATH
], dest
[MAX_PATH
];
1371 static const char prefix
[] = "pfx";
1377 ret
= GetTempPathA(MAX_PATH
, tempdir
);
1378 ok(ret
!= 0, "GetTempPathA error %d\n", GetLastError());
1379 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
1381 ret
= GetTempFileNameA(tempdir
, prefix
, 0, source
);
1382 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
1384 ret
= GetTempFileNameA(tempdir
, prefix
, 0, dest
);
1385 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
1387 ret
= MoveFileA(source
, dest
);
1388 ok(!ret
&& GetLastError() == ERROR_ALREADY_EXISTS
,
1389 "MoveFileA: unexpected error %d\n", GetLastError());
1391 ret
= DeleteFileA(dest
);
1392 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
1394 hfile
= CreateFileA(source
, GENERIC_READ
| GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
, 0, 0);
1395 ok(hfile
!= INVALID_HANDLE_VALUE
, "failed to open source file\n");
1397 retok
= WriteFile(hfile
, prefix
, sizeof(prefix
), &ret
, NULL
);
1398 ok( retok
&& ret
== sizeof(prefix
),
1399 "WriteFile error %d\n", GetLastError());
1401 hmapfile
= CreateFileMapping(hfile
, NULL
, PAGE_READONLY
| SEC_COMMIT
, 0, 0, NULL
);
1402 ok(hmapfile
!= NULL
, "CreateFileMapping: error %d\n", GetLastError());
1404 ret
= MoveFileA(source
, dest
);
1406 ok(!ret
, "MoveFileA: expected failure\n");
1407 ok(GetLastError() == ERROR_SHARING_VIOLATION
||
1408 broken(GetLastError() == ERROR_ACCESS_DENIED
), /* Win9x and WinMe */
1409 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1412 CloseHandle(hmapfile
);
1415 /* if MoveFile succeeded, move back to dest */
1416 if (ret
) MoveFile(dest
, source
);
1418 hfile
= CreateFileA(source
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
1419 ok(hfile
!= INVALID_HANDLE_VALUE
, "failed to open source file\n");
1421 hmapfile
= CreateFileMapping(hfile
, NULL
, PAGE_READONLY
| SEC_COMMIT
, 0, 0, NULL
);
1422 ok(hmapfile
!= NULL
, "CreateFileMapping: error %d\n", GetLastError());
1424 ret
= MoveFileA(source
, dest
);
1426 ok(!ret
, "MoveFileA: expected failure\n");
1427 ok(GetLastError() == ERROR_SHARING_VIOLATION
||
1428 broken(GetLastError() == ERROR_ACCESS_DENIED
), /* Win9x and WinMe */
1429 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1432 CloseHandle(hmapfile
);
1435 /* if MoveFile succeeded, move back to dest */
1436 if (ret
) MoveFile(dest
, source
);
1438 ret
= MoveFileA(source
, dest
);
1439 ok(ret
, "MoveFileA: failed, error %d\n", GetLastError());
1441 lstrcatA(tempdir
, "Remove Me");
1442 ret
= CreateDirectoryA(tempdir
, NULL
);
1443 ok(ret
== TRUE
, "CreateDirectoryA failed\n");
1445 lstrcpyA(source
, dest
);
1446 lstrcpyA(dest
, tempdir
);
1447 lstrcatA(dest
, "\\wild?.*");
1448 /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
1449 ret
= MoveFileA(source
, dest
);
1450 ok(!ret
, "MoveFileA: shouldn't move to wildcard file\n");
1451 ok(GetLastError() == ERROR_INVALID_NAME
|| /* NT */
1452 GetLastError() == ERROR_FILE_NOT_FOUND
, /* Win9x */
1453 "MoveFileA: with wildcards, unexpected error %d\n", GetLastError());
1454 if (ret
|| (GetLastError() != ERROR_INVALID_NAME
))
1456 WIN32_FIND_DATAA fd
;
1457 char temppath
[MAX_PATH
];
1460 lstrcpyA(temppath
, tempdir
);
1461 lstrcatA(temppath
, "\\*.*");
1462 hFind
= FindFirstFileA(temppath
, &fd
);
1463 if (INVALID_HANDLE_VALUE
!= hFind
)
1468 lpName
= fd
.cAlternateFileName
;
1470 lpName
= fd
.cFileName
;
1471 ok(IsDotDir(lpName
), "MoveFileA: wildcards file created!\n");
1473 while (FindNextFileA(hFind
, &fd
));
1477 ret
= DeleteFileA(source
);
1478 ok(ret
, "DeleteFileA: error %d\n", GetLastError());
1479 ret
= DeleteFileA(dest
);
1480 ok(!ret
, "DeleteFileA: error %d\n", GetLastError());
1481 ret
= RemoveDirectoryA(tempdir
);
1482 ok(ret
, "DeleteDirectoryA: error %d\n", GetLastError());
1485 static void test_MoveFileW(void)
1487 WCHAR temp_path
[MAX_PATH
];
1488 WCHAR source
[MAX_PATH
], dest
[MAX_PATH
];
1489 static const WCHAR prefix
[] = {'p','f','x',0};
1492 ret
= GetTempPathW(MAX_PATH
, temp_path
);
1493 if (ret
== 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1495 win_skip("GetTempPathW is not available\n");
1498 ok(ret
!= 0, "GetTempPathW error %d\n", GetLastError());
1499 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
1501 ret
= GetTempFileNameW(temp_path
, prefix
, 0, source
);
1502 ok(ret
!= 0, "GetTempFileNameW error %d\n", GetLastError());
1504 ret
= GetTempFileNameW(temp_path
, prefix
, 0, dest
);
1505 ok(ret
!= 0, "GetTempFileNameW error %d\n", GetLastError());
1507 ret
= MoveFileW(source
, dest
);
1508 ok(!ret
&& GetLastError() == ERROR_ALREADY_EXISTS
,
1509 "CopyFileW: unexpected error %d\n", GetLastError());
1511 ret
= DeleteFileW(source
);
1512 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
1513 ret
= DeleteFileW(dest
);
1514 ok(ret
, "DeleteFileW: error %d\n", GetLastError());
1517 #define PATTERN_OFFSET 0x10
1519 static void test_offset_in_overlapped_structure(void)
1525 BYTE buf
[256], pattern
[] = "TeSt";
1527 char temp_path
[MAX_PATH
], temp_fname
[MAX_PATH
];
1530 ret
=GetTempPathA(MAX_PATH
, temp_path
);
1531 ok( ret
, "GetTempPathA error %d\n", GetLastError());
1532 ret
=GetTempFileNameA(temp_path
, "pfx", 0, temp_fname
);
1533 ok( ret
, "GetTempFileNameA error %d\n", GetLastError());
1535 /*** Write File *****************************************************/
1537 hFile
= CreateFileA(temp_fname
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
1538 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA error %d\n", GetLastError());
1540 for(i
= 0; i
< sizeof(buf
); i
++) buf
[i
] = i
;
1541 ret
= WriteFile(hFile
, buf
, sizeof(buf
), &done
, NULL
);
1542 ok( ret
, "WriteFile error %d\n", GetLastError());
1543 ok(done
== sizeof(buf
), "expected number of bytes written %u\n", done
);
1545 memset(&ov
, 0, sizeof(ov
));
1546 S(U(ov
)).Offset
= PATTERN_OFFSET
;
1547 S(U(ov
)).OffsetHigh
= 0;
1548 rc
=WriteFile(hFile
, pattern
, sizeof(pattern
), &done
, &ov
);
1549 /* Win 9x does not support the overlapped I/O on files */
1550 if (rc
|| GetLastError()!=ERROR_INVALID_PARAMETER
) {
1551 ok(rc
, "WriteFile error %d\n", GetLastError());
1552 ok(done
== sizeof(pattern
), "expected number of bytes written %u\n", done
);
1553 offset
= SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
);
1554 ok(offset
== PATTERN_OFFSET
+ sizeof(pattern
), "wrong file offset %d\n", offset
);
1556 S(U(ov
)).Offset
= sizeof(buf
) * 2;
1557 S(U(ov
)).OffsetHigh
= 0;
1558 ret
= WriteFile(hFile
, pattern
, sizeof(pattern
), &done
, &ov
);
1559 ok( ret
, "WriteFile error %d\n", GetLastError());
1560 ok(done
== sizeof(pattern
), "expected number of bytes written %u\n", done
);
1561 offset
= SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
);
1562 ok(offset
== sizeof(buf
) * 2 + sizeof(pattern
), "wrong file offset %d\n", offset
);
1567 /*** Read File *****************************************************/
1569 hFile
= CreateFileA(temp_fname
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0);
1570 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA error %d\n", GetLastError());
1572 memset(buf
, 0, sizeof(buf
));
1573 memset(&ov
, 0, sizeof(ov
));
1574 S(U(ov
)).Offset
= PATTERN_OFFSET
;
1575 S(U(ov
)).OffsetHigh
= 0;
1576 rc
=ReadFile(hFile
, buf
, sizeof(pattern
), &done
, &ov
);
1577 /* Win 9x does not support the overlapped I/O on files */
1578 if (rc
|| GetLastError()!=ERROR_INVALID_PARAMETER
) {
1579 ok(rc
, "ReadFile error %d\n", GetLastError());
1580 ok(done
== sizeof(pattern
), "expected number of bytes read %u\n", done
);
1581 offset
= SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
);
1582 ok(offset
== PATTERN_OFFSET
+ sizeof(pattern
), "wrong file offset %d\n", offset
);
1583 ok(!memcmp(buf
, pattern
, sizeof(pattern
)), "pattern match failed\n");
1588 ret
= DeleteFileA(temp_fname
);
1589 ok( ret
, "DeleteFileA error %d\n", GetLastError());
1592 static void test_LockFile(void)
1594 HANDLE handle
, handle2
;
1596 OVERLAPPED overlapped
;
1597 int limited_LockFile
;
1598 int limited_UnLockFile
;
1601 handle
= CreateFileA( filename
, GENERIC_READ
| GENERIC_WRITE
,
1602 FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
1603 CREATE_ALWAYS
, 0, 0 );
1604 if (handle
== INVALID_HANDLE_VALUE
)
1606 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
1609 handle2
= CreateFileA( filename
, GENERIC_READ
| GENERIC_WRITE
,
1610 FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
1611 OPEN_EXISTING
, 0, 0 );
1612 if (handle2
== INVALID_HANDLE_VALUE
)
1614 ok( 0, "couldn't open file \"%s\" (err=%d)\n", filename
, GetLastError() );
1617 ok( WriteFile( handle
, sillytext
, strlen(sillytext
), &written
, NULL
), "write failed\n" );
1619 ok( LockFile( handle
, 0, 0, 0, 0 ), "LockFile failed\n" );
1620 ok( UnlockFile( handle
, 0, 0, 0, 0 ), "UnlockFile failed\n" );
1622 limited_UnLockFile
= 0;
1623 if (UnlockFile( handle
, 0, 0, 0, 0 ))
1625 limited_UnLockFile
= 1;
1628 ok( LockFile( handle
, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
1629 /* overlapping locks must fail */
1630 ok( !LockFile( handle
, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
1631 ok( !LockFile( handle
, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
1632 /* non-overlapping locks must succeed */
1633 ok( LockFile( handle
, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
1635 ok( !UnlockFile( handle
, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
1636 ok( UnlockFile( handle
, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
1637 ok( !UnlockFile( handle
, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
1638 ok( UnlockFile( handle
, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
1640 S(U(overlapped
)).Offset
= 100;
1641 S(U(overlapped
)).OffsetHigh
= 0;
1642 overlapped
.hEvent
= 0;
1644 /* Test for broken LockFileEx a la Windows 95 OSR2. */
1645 if (LockFileEx( handle
, 0, 0, 100, 0, &overlapped
))
1647 /* LockFileEx is probably OK, test it more. */
1648 ok( LockFileEx( handle
, 0, 0, 100, 0, &overlapped
),
1649 "LockFileEx 100,100 failed\n" );
1652 /* overlapping shared locks are OK */
1653 S(U(overlapped
)).Offset
= 150;
1654 limited_UnLockFile
|| ok( LockFileEx( handle
, 0, 0, 100, 0, &overlapped
), "LockFileEx 150,100 failed\n" );
1656 /* but exclusive is not */
1657 ok( !LockFileEx( handle
, LOCKFILE_EXCLUSIVE_LOCK
|LOCKFILE_FAIL_IMMEDIATELY
,
1658 0, 50, 0, &overlapped
),
1659 "LockFileEx exclusive 150,50 succeeded\n" );
1660 if (!UnlockFileEx( handle
, 0, 100, 0, &overlapped
))
1661 { /* UnLockFile is capable. */
1662 S(U(overlapped
)).Offset
= 100;
1663 ok( !UnlockFileEx( handle
, 0, 100, 0, &overlapped
),
1664 "UnlockFileEx 150,100 again succeeded\n" );
1667 /* shared lock can overlap exclusive if handles are equal */
1668 S(U(overlapped
)).Offset
= 300;
1669 ok( LockFileEx( handle
, LOCKFILE_EXCLUSIVE_LOCK
, 0, 100, 0, &overlapped
),
1670 "LockFileEx exclusive 300,100 failed\n" );
1671 ok( !LockFileEx( handle2
, LOCKFILE_FAIL_IMMEDIATELY
, 0, 100, 0, &overlapped
),
1672 "LockFileEx handle2 300,100 succeeded\n" );
1673 ret
= LockFileEx( handle
, LOCKFILE_FAIL_IMMEDIATELY
, 0, 100, 0, &overlapped
);
1675 ok( ret
, "LockFileEx 300,100 failed\n" );
1676 ok( UnlockFileEx( handle
, 0, 100, 0, &overlapped
), "UnlockFileEx 300,100 failed\n" );
1677 /* exclusive lock is removed first */
1678 ok( LockFileEx( handle2
, LOCKFILE_FAIL_IMMEDIATELY
, 0, 100, 0, &overlapped
),
1679 "LockFileEx handle2 300,100 failed\n" );
1680 ok( UnlockFileEx( handle2
, 0, 100, 0, &overlapped
), "UnlockFileEx 300,100 failed\n" );
1682 ok( UnlockFileEx( handle
, 0, 100, 0, &overlapped
), "UnlockFileEx 300,100 failed\n" );
1684 ret
= LockFile( handle
, 0, 0x10000000, 0, 0xf0000000 );
1687 ok( !LockFile( handle
, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
1688 ok( !LockFile( handle
, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
1689 ok( UnlockFile( handle
, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
1692 ok( GetLastError() == ERROR_INVALID_PARAMETER
, "wrong LockFile error %u\n", GetLastError() );
1694 /* wrap-around lock should not do anything */
1695 /* (but still succeeds on NT4 so we don't check result) */
1696 LockFile( handle
, 0, 0x10000000, 0, 0xf0000001 );
1698 limited_LockFile
= 0;
1699 if (!LockFile( handle
, ~0, ~0, 1, 0 ))
1701 limited_LockFile
= 1;
1704 limited_UnLockFile
|| ok( UnlockFile( handle
, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
1706 /* zero-byte lock */
1707 ok( LockFile( handle
, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
1708 if (!limited_LockFile
) ok( !LockFile( handle
, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
1709 ok( LockFile( handle
, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
1710 if (!limited_LockFile
) ok( !LockFile( handle
, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
1712 ok( UnlockFile( handle
, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
1713 ok( !UnlockFile( handle
, 100, 0, 10, 0 ), "UnlockFile 100,10 succeeded\n" );
1715 ok( UnlockFile( handle
, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
1717 CloseHandle( handle2
);
1719 CloseHandle( handle
);
1720 DeleteFileA( filename
);
1723 static BOOL
create_fake_dll( LPCSTR filename
)
1725 IMAGE_DOS_HEADER
*dos
;
1726 IMAGE_NT_HEADERS
*nt
;
1727 IMAGE_SECTION_HEADER
*sec
;
1729 DWORD lfanew
= sizeof(*dos
);
1730 DWORD size
= lfanew
+ sizeof(*nt
) + sizeof(*sec
);
1734 HANDLE file
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
1735 if (file
== INVALID_HANDLE_VALUE
) return FALSE
;
1737 buffer
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
1739 dos
= (IMAGE_DOS_HEADER
*)buffer
;
1740 dos
->e_magic
= IMAGE_DOS_SIGNATURE
;
1741 dos
->e_cblp
= sizeof(*dos
);
1743 dos
->e_cparhdr
= lfanew
/ 16;
1744 dos
->e_minalloc
= 0;
1745 dos
->e_maxalloc
= 0xffff;
1748 dos
->e_lfarlc
= lfanew
;
1749 dos
->e_lfanew
= lfanew
;
1751 nt
= (IMAGE_NT_HEADERS
*)(buffer
+ lfanew
);
1752 nt
->Signature
= IMAGE_NT_SIGNATURE
;
1753 #if defined __i386__
1754 nt
->FileHeader
.Machine
= IMAGE_FILE_MACHINE_I386
;
1755 #elif defined __x86_64__
1756 nt
->FileHeader
.Machine
= IMAGE_FILE_MACHINE_AMD64
;
1757 #elif defined __powerpc__
1758 nt
->FileHeader
.Machine
= IMAGE_FILE_MACHINE_POWERPC
;
1759 #elif defined __sparc__
1760 nt
->FileHeader
.Machine
= IMAGE_FILE_MACHINE_SPARC
;
1761 #elif defined __arm__
1762 nt
->FileHeader
.Machine
= IMAGE_FILE_MACHINE_ARM
;
1764 # error You must specify the machine type
1766 nt
->FileHeader
.NumberOfSections
= 1;
1767 nt
->FileHeader
.SizeOfOptionalHeader
= IMAGE_SIZEOF_NT_OPTIONAL_HEADER
;
1768 nt
->FileHeader
.Characteristics
= IMAGE_FILE_DLL
| IMAGE_FILE_EXECUTABLE_IMAGE
;
1769 nt
->OptionalHeader
.Magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
1770 nt
->OptionalHeader
.MajorLinkerVersion
= 1;
1771 nt
->OptionalHeader
.MinorLinkerVersion
= 0;
1772 nt
->OptionalHeader
.ImageBase
= 0x10000000;
1773 nt
->OptionalHeader
.SectionAlignment
= 0x1000;
1774 nt
->OptionalHeader
.FileAlignment
= 0x1000;
1775 nt
->OptionalHeader
.MajorOperatingSystemVersion
= 1;
1776 nt
->OptionalHeader
.MinorOperatingSystemVersion
= 0;
1777 nt
->OptionalHeader
.MajorImageVersion
= 1;
1778 nt
->OptionalHeader
.MinorImageVersion
= 0;
1779 nt
->OptionalHeader
.MajorSubsystemVersion
= 4;
1780 nt
->OptionalHeader
.MinorSubsystemVersion
= 0;
1781 nt
->OptionalHeader
.SizeOfImage
= 0x2000;
1782 nt
->OptionalHeader
.SizeOfHeaders
= size
;
1783 nt
->OptionalHeader
.Subsystem
= IMAGE_SUBSYSTEM_WINDOWS_GUI
;
1784 nt
->OptionalHeader
.NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
1786 sec
= (IMAGE_SECTION_HEADER
*)(nt
+ 1);
1787 memcpy( sec
->Name
, ".rodata", sizeof(".rodata") );
1788 sec
->Misc
.VirtualSize
= 0x1000;
1789 sec
->VirtualAddress
= 0x1000;
1790 sec
->SizeOfRawData
= 0;
1791 sec
->PointerToRawData
= 0;
1792 sec
->Characteristics
= IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
;
1794 ret
= WriteFile( file
, buffer
, size
, &written
, NULL
) && written
== size
;
1795 HeapFree( GetProcessHeap(), 0, buffer
);
1796 CloseHandle( file
);
1800 static unsigned int map_file_access( unsigned int access
)
1802 if (access
& GENERIC_READ
) access
|= FILE_GENERIC_READ
;
1803 if (access
& GENERIC_WRITE
) access
|= FILE_GENERIC_WRITE
;
1804 if (access
& GENERIC_EXECUTE
) access
|= FILE_GENERIC_EXECUTE
;
1805 if (access
& GENERIC_ALL
) access
|= FILE_ALL_ACCESS
;
1806 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
1809 static int is_sharing_compatible( DWORD access1
, DWORD sharing1
, DWORD access2
, DWORD sharing2
)
1811 access1
= map_file_access( access1
);
1812 access2
= map_file_access( access2
);
1813 access1
&= FILE_READ_DATA
| FILE_WRITE_DATA
| FILE_APPEND_DATA
| FILE_EXECUTE
| DELETE
;
1814 access2
&= FILE_READ_DATA
| FILE_WRITE_DATA
| FILE_APPEND_DATA
| FILE_EXECUTE
| DELETE
;
1816 if (!access1
) sharing1
= FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
;
1817 if (!access2
) sharing2
= FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
;
1819 if ((access1
& (FILE_READ_DATA
|FILE_EXECUTE
)) && !(sharing2
& FILE_SHARE_READ
)) return 0;
1820 if ((access1
& (FILE_WRITE_DATA
|FILE_APPEND_DATA
)) && !(sharing2
& FILE_SHARE_WRITE
)) return 0;
1821 if ((access1
& DELETE
) && !(sharing2
& FILE_SHARE_DELETE
)) return 0;
1822 if ((access2
& (FILE_READ_DATA
|FILE_EXECUTE
)) && !(sharing1
& FILE_SHARE_READ
)) return 0;
1823 if ((access2
& (FILE_WRITE_DATA
|FILE_APPEND_DATA
)) && !(sharing1
& FILE_SHARE_WRITE
)) return 0;
1824 if ((access2
& DELETE
) && !(sharing1
& FILE_SHARE_DELETE
)) return 0;
1828 static int is_sharing_map_compatible( DWORD map_access
, DWORD access2
, DWORD sharing2
)
1830 if ((map_access
== PAGE_READWRITE
|| map_access
== PAGE_EXECUTE_READWRITE
) &&
1831 !(sharing2
& FILE_SHARE_WRITE
)) return 0;
1832 access2
= map_file_access( access2
);
1833 if ((map_access
& SEC_IMAGE
) && (access2
& FILE_WRITE_DATA
)) return 0;
1837 static void test_file_sharing(void)
1839 static const DWORD access_modes
[] =
1840 { 0, GENERIC_READ
, GENERIC_WRITE
, GENERIC_READ
|GENERIC_WRITE
,
1841 DELETE
, GENERIC_READ
|DELETE
, GENERIC_WRITE
|DELETE
, GENERIC_READ
|GENERIC_WRITE
|DELETE
,
1842 GENERIC_EXECUTE
, GENERIC_EXECUTE
| DELETE
,
1843 FILE_READ_DATA
, FILE_WRITE_DATA
, FILE_APPEND_DATA
, FILE_READ_EA
, FILE_WRITE_EA
,
1844 FILE_READ_DATA
| FILE_EXECUTE
, FILE_WRITE_DATA
| FILE_EXECUTE
, FILE_APPEND_DATA
| FILE_EXECUTE
,
1845 FILE_READ_EA
| FILE_EXECUTE
, FILE_WRITE_EA
| FILE_EXECUTE
, FILE_EXECUTE
,
1846 FILE_DELETE_CHILD
, FILE_READ_ATTRIBUTES
, FILE_WRITE_ATTRIBUTES
};
1847 static const DWORD sharing_modes
[] =
1848 { 0, FILE_SHARE_READ
,
1849 FILE_SHARE_WRITE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1850 FILE_SHARE_DELETE
, FILE_SHARE_READ
|FILE_SHARE_DELETE
,
1851 FILE_SHARE_WRITE
|FILE_SHARE_DELETE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
};
1852 static const DWORD mapping_modes
[] =
1853 { PAGE_READONLY
, PAGE_WRITECOPY
, PAGE_READWRITE
, SEC_IMAGE
| PAGE_WRITECOPY
};
1858 /* make sure the file exists */
1859 if (!create_fake_dll( filename
))
1861 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename
, GetLastError());
1865 for (a1
= 0; a1
< sizeof(access_modes
)/sizeof(access_modes
[0]); a1
++)
1867 for (s1
= 0; s1
< sizeof(sharing_modes
)/sizeof(sharing_modes
[0]); s1
++)
1869 SetLastError(0xdeadbeef);
1870 h
= CreateFileA( filename
, access_modes
[a1
], sharing_modes
[s1
],
1871 NULL
, OPEN_EXISTING
, 0, 0 );
1872 if (h
== INVALID_HANDLE_VALUE
)
1874 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
1877 for (a2
= 0; a2
< sizeof(access_modes
)/sizeof(access_modes
[0]); a2
++)
1879 for (s2
= 0; s2
< sizeof(sharing_modes
)/sizeof(sharing_modes
[0]); s2
++)
1881 SetLastError(0xdeadbeef);
1882 h2
= CreateFileA( filename
, access_modes
[a2
], sharing_modes
[s2
],
1883 NULL
, OPEN_EXISTING
, 0, 0 );
1884 ret
= GetLastError();
1885 if (is_sharing_compatible( access_modes
[a1
], sharing_modes
[s1
],
1886 access_modes
[a2
], sharing_modes
[s2
] ))
1888 ok( h2
!= INVALID_HANDLE_VALUE
,
1889 "open failed for modes %x/%x/%x/%x\n",
1890 access_modes
[a1
], sharing_modes
[s1
],
1891 access_modes
[a2
], sharing_modes
[s2
] );
1892 ok( ret
== 0, "wrong error code %d\n", ret
);
1896 ok( h2
== INVALID_HANDLE_VALUE
,
1897 "open succeeded for modes %x/%x/%x/%x\n",
1898 access_modes
[a1
], sharing_modes
[s1
],
1899 access_modes
[a2
], sharing_modes
[s2
] );
1900 ok( ret
== ERROR_SHARING_VIOLATION
,
1901 "wrong error code %d\n", ret
);
1903 if (h2
!= INVALID_HANDLE_VALUE
) CloseHandle( h2
);
1910 for (a1
= 0; a1
< sizeof(mapping_modes
)/sizeof(mapping_modes
[0]); a1
++)
1914 create_fake_dll( filename
);
1915 SetLastError(0xdeadbeef);
1916 h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
1917 if (h
== INVALID_HANDLE_VALUE
)
1919 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename
,GetLastError());
1922 m
= CreateFileMappingA( h
, NULL
, mapping_modes
[a1
], 0, 0, NULL
);
1923 ok( m
!= 0, "failed to create mapping %x err %u\n", mapping_modes
[a1
], GetLastError() );
1927 for (a2
= 0; a2
< sizeof(access_modes
)/sizeof(access_modes
[0]); a2
++)
1929 for (s2
= 0; s2
< sizeof(sharing_modes
)/sizeof(sharing_modes
[0]); s2
++)
1931 SetLastError(0xdeadbeef);
1932 h2
= CreateFileA( filename
, access_modes
[a2
], sharing_modes
[s2
],
1933 NULL
, OPEN_EXISTING
, 0, 0 );
1935 ret
= GetLastError();
1936 if (h2
== INVALID_HANDLE_VALUE
)
1938 ok( !is_sharing_map_compatible(mapping_modes
[a1
], access_modes
[a2
], sharing_modes
[s2
]),
1939 "open failed for modes map %x/%x/%x\n",
1940 mapping_modes
[a1
], access_modes
[a2
], sharing_modes
[s2
] );
1941 ok( ret
== ERROR_SHARING_VIOLATION
,
1942 "wrong error code %d\n", ret
);
1946 if (!is_sharing_map_compatible(mapping_modes
[a1
], access_modes
[a2
], sharing_modes
[s2
]))
1947 ok( broken(1), /* no checking on nt4 */
1948 "open succeeded for modes map %x/%x/%x\n",
1949 mapping_modes
[a1
], access_modes
[a2
], sharing_modes
[s2
] );
1950 ok( ret
== 0xdeadbeef /* Win9x */ ||
1952 "wrong error code %d\n", ret
);
1958 /* try CREATE_ALWAYS over an existing mapping */
1959 SetLastError(0xdeadbeef);
1960 h2
= CreateFileA( filename
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1961 NULL
, CREATE_ALWAYS
, 0, 0 );
1962 ret
= GetLastError();
1963 if (mapping_modes
[a1
] & SEC_IMAGE
)
1965 ok( h2
== INVALID_HANDLE_VALUE
, "create succeeded for map %x\n", mapping_modes
[a1
] );
1966 ok( ret
== ERROR_SHARING_VIOLATION
, "wrong error code %d for %x\n", ret
, mapping_modes
[a1
] );
1970 ok( h2
== INVALID_HANDLE_VALUE
, "create succeeded for map %x\n", mapping_modes
[a1
] );
1971 ok( ret
== ERROR_USER_MAPPED_FILE
, "wrong error code %d for %x\n", ret
, mapping_modes
[a1
] );
1973 if (h2
!= INVALID_HANDLE_VALUE
) CloseHandle( h2
);
1975 /* try DELETE_ON_CLOSE over an existing mapping */
1976 SetLastError(0xdeadbeef);
1977 h2
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1978 NULL
, OPEN_EXISTING
, FILE_FLAG_DELETE_ON_CLOSE
, 0 );
1979 ret
= GetLastError();
1980 if (mapping_modes
[a1
] & SEC_IMAGE
)
1982 ok( h2
== INVALID_HANDLE_VALUE
, "create succeeded for map %x\n", mapping_modes
[a1
] );
1983 ok( ret
== ERROR_ACCESS_DENIED
, "wrong error code %d for %x\n", ret
, mapping_modes
[a1
] );
1987 ok( h2
!= INVALID_HANDLE_VALUE
, "open failed for map %x err %u\n", mapping_modes
[a1
], ret
);
1989 if (h2
!= INVALID_HANDLE_VALUE
) CloseHandle( h2
);
1994 SetLastError(0xdeadbeef);
1995 h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0, 0 );
1996 ok( h
!= INVALID_HANDLE_VALUE
, "CreateFileA error %d\n", GetLastError() );
1998 SetLastError(0xdeadbeef);
1999 h2
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0 );
2000 ok( h2
== INVALID_HANDLE_VALUE
, "CreateFileA should fail\n");
2001 ok( GetLastError() == ERROR_SHARING_VIOLATION
, "wrong error code %d\n", GetLastError() );
2003 h2
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
, 0, 0 );
2004 ok( h2
!= INVALID_HANDLE_VALUE
, "CreateFileA error %d\n", GetLastError() );
2009 DeleteFileA( filename
);
2012 static char get_windows_drive(void)
2014 char windowsdir
[MAX_PATH
];
2015 GetWindowsDirectory(windowsdir
, sizeof(windowsdir
));
2016 return windowsdir
[0];
2019 static void test_FindFirstFileA(void)
2022 WIN32_FIND_DATAA data
;
2024 char buffer
[5] = "C:\\";
2026 char nonexistent
[MAX_PATH
];
2028 /* try FindFirstFileA on "C:\" */
2029 buffer
[0] = get_windows_drive();
2031 SetLastError( 0xdeadbeaf );
2032 handle
= FindFirstFileA(buffer
, &data
);
2033 err
= GetLastError();
2034 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on root directory should fail\n" );
2035 ok ( err
== ERROR_FILE_NOT_FOUND
, "Bad Error number %d\n", err
);
2037 /* try FindFirstFileA on "C:\*" */
2038 strcpy(buffer2
, buffer
);
2039 strcat(buffer2
, "*");
2040 handle
= FindFirstFileA(buffer2
, &data
);
2041 ok ( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on %s should succeed\n", buffer2
);
2042 ok ( strcmp( data
.cFileName
, "." ) && strcmp( data
.cFileName
, ".." ),
2043 "FindFirstFile shouldn't return '%s' in drive root\n", data
.cFileName
);
2044 if (FindNextFileA( handle
, &data
))
2045 ok ( strcmp( data
.cFileName
, "." ) && strcmp( data
.cFileName
, ".." ),
2046 "FindNextFile shouldn't return '%s' in drive root\n", data
.cFileName
);
2047 ok ( FindClose(handle
) == TRUE
, "Failed to close handle %s\n", buffer2
);
2049 /* try FindFirstFileA on windows dir */
2050 GetWindowsDirectory( buffer2
, sizeof(buffer2
) );
2051 strcat(buffer2
, "\\*");
2052 handle
= FindFirstFileA(buffer2
, &data
);
2053 ok( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on %s should succeed\n", buffer2
);
2054 ok( !strcmp( data
.cFileName
, "." ), "FindFirstFile should return '.' first\n" );
2055 ok( FindNextFileA( handle
, &data
), "FindNextFile failed\n" );
2056 ok( !strcmp( data
.cFileName
, ".." ), "FindNextFile should return '..' as second entry\n" );
2057 while (FindNextFileA( handle
, &data
))
2058 ok ( strcmp( data
.cFileName
, "." ) && strcmp( data
.cFileName
, ".." ),
2059 "FindNextFile shouldn't return '%s'\n", data
.cFileName
);
2060 ok ( FindClose(handle
) == TRUE
, "Failed to close handle %s\n", buffer2
);
2062 /* try FindFirstFileA on "C:\foo\" */
2063 SetLastError( 0xdeadbeaf );
2064 if (!GetTempFileNameA( buffer
, "foo", 0, nonexistent
) && GetLastError() == ERROR_ACCESS_DENIED
)
2067 GetTempPathA( sizeof(tmp
), tmp
);
2068 GetTempFileNameA( tmp
, "foo", 0, nonexistent
);
2070 DeleteFileA( nonexistent
);
2071 strcpy(buffer2
, nonexistent
);
2072 strcat(buffer2
, "\\");
2073 handle
= FindFirstFileA(buffer2
, &data
);
2074 err
= GetLastError();
2075 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2077 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2080 /* try FindFirstFileA on "C:\foo\bar.txt" */
2081 SetLastError( 0xdeadbeaf );
2082 strcpy(buffer2
, nonexistent
);
2083 strcat(buffer2
, "\\bar.txt");
2084 handle
= FindFirstFileA(buffer2
, &data
);
2085 err
= GetLastError();
2086 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2087 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2089 /* try FindFirstFileA on "C:\foo\*.*" */
2090 SetLastError( 0xdeadbeaf );
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 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2098 /* try FindFirstFileA on "foo\bar.txt" */
2099 SetLastError( 0xdeadbeaf );
2100 strcpy(buffer2
, nonexistent
+ 3);
2101 strcat(buffer2
, "\\bar.txt");
2102 handle
= FindFirstFileA(buffer2
, &data
);
2103 err
= GetLastError();
2104 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2105 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2107 /* try FindFirstFileA on "c:\nul" */
2108 SetLastError( 0xdeadbeaf );
2109 strcpy(buffer2
, buffer
);
2110 strcat(buffer2
, "nul");
2111 handle
= FindFirstFileA(buffer2
, &data
);
2112 err
= GetLastError();
2113 ok( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on %s failed: %d\n", buffer2
, err
);
2114 ok( 0 == lstrcmpiA(data
.cFileName
, "nul"), "wrong name %s\n", data
.cFileName
);
2115 ok( FILE_ATTRIBUTE_ARCHIVE
== data
.dwFileAttributes
||
2116 FILE_ATTRIBUTE_DEVICE
== data
.dwFileAttributes
/* Win9x */,
2117 "wrong attributes %x\n", data
.dwFileAttributes
);
2118 if (data
.dwFileAttributes
== FILE_ATTRIBUTE_ARCHIVE
)
2120 ok( 0 == data
.nFileSizeHigh
, "wrong size %d\n", data
.nFileSizeHigh
);
2121 ok( 0 == data
.nFileSizeLow
, "wrong size %d\n", data
.nFileSizeLow
);
2123 SetLastError( 0xdeadbeaf );
2124 ok( !FindNextFileA( handle
, &data
), "FindNextFileA succeeded\n" );
2125 ok( GetLastError() == ERROR_NO_MORE_FILES
, "bad error %d\n", GetLastError() );
2126 ok( FindClose( handle
), "failed to close handle\n" );
2128 /* try FindFirstFileA on "lpt1" */
2129 SetLastError( 0xdeadbeaf );
2130 strcpy(buffer2
, "lpt1");
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
, "lpt1"), "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
)
2140 ok( 0 == data
.nFileSizeHigh
, "wrong size %d\n", data
.nFileSizeHigh
);
2141 ok( 0 == data
.nFileSizeLow
, "wrong size %d\n", data
.nFileSizeLow
);
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" );
2148 /* try FindFirstFileA on "c:\nul\*" */
2149 SetLastError( 0xdeadbeaf );
2150 strcpy(buffer2
, buffer
);
2151 strcat(buffer2
, "nul\\*");
2152 handle
= FindFirstFileA(buffer2
, &data
);
2153 err
= GetLastError();
2154 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2155 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2157 /* try FindFirstFileA on "c:\nul*" */
2158 SetLastError( 0xdeadbeaf );
2159 strcpy(buffer2
, buffer
);
2160 strcat(buffer2
, "nul*");
2161 handle
= FindFirstFileA(buffer2
, &data
);
2162 err
= GetLastError();
2163 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2164 ok ( err
== ERROR_FILE_NOT_FOUND
, "Bad Error number %d\n", err
);
2166 /* try FindFirstFileA on "c:\foo\bar\nul" */
2167 SetLastError( 0xdeadbeaf );
2168 strcpy(buffer2
, buffer
);
2169 strcat(buffer2
, "foo\\bar\\nul");
2170 handle
= FindFirstFileA(buffer2
, &data
);
2171 err
= GetLastError();
2172 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2173 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2175 /* try FindFirstFileA on "c:\foo\nul\bar" */
2176 SetLastError( 0xdeadbeaf );
2177 strcpy(buffer2
, buffer
);
2178 strcat(buffer2
, "foo\\nul\\bar");
2179 handle
= FindFirstFileA(buffer2
, &data
);
2180 err
= GetLastError();
2181 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on %s should Fail\n", buffer2
);
2182 ok ( err
== ERROR_PATH_NOT_FOUND
, "Bad Error number %d\n", err
);
2185 static void test_FindNextFileA(void)
2188 WIN32_FIND_DATAA search_results
;
2190 char buffer
[5] = "C:\\*";
2192 buffer
[0] = get_windows_drive();
2193 handle
= FindFirstFileA(buffer
,&search_results
);
2194 ok ( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on C:\\* should succeed\n" );
2195 while (FindNextFile(handle
, &search_results
))
2197 /* get to the end of the files */
2199 ok ( FindClose(handle
) == TRUE
, "Failed to close handle\n");
2200 err
= GetLastError();
2201 ok ( err
== ERROR_NO_MORE_FILES
, "GetLastError should return ERROR_NO_MORE_FILES\n");
2204 static void test_FindFirstFileExA(FINDEX_SEARCH_OPS search_ops
)
2206 WIN32_FIND_DATAA search_results
;
2210 if (!pFindFirstFileExA
)
2212 win_skip("FindFirstFileExA() is missing\n");
2216 CreateDirectoryA("test-dir", NULL
);
2217 _lclose(_lcreat("test-dir\\file1", 0));
2218 _lclose(_lcreat("test-dir\\file2", 0));
2219 CreateDirectoryA("test-dir\\dir1", NULL
);
2220 SetLastError(0xdeadbeef);
2221 handle
= pFindFirstFileExA("test-dir\\*", FindExInfoStandard
, &search_results
, search_ops
, NULL
, 0);
2222 if (handle
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
2224 win_skip("FindFirstFileExA is not implemented\n");
2227 ok(handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile failed (err=%u)\n", GetLastError());
2228 ok(strcmp(search_results
.cFileName
, ".") == 0, "First entry should be '.', is %s\n", search_results
.cFileName
);
2230 #define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
2232 ok(FindNextFile(handle
, &search_results
), "Fetching second file failed\n");
2233 ok(strcmp(search_results
.cFileName
, "..") == 0, "Second entry should be '..' is %s\n", search_results
.cFileName
);
2235 ok(FindNextFile(handle
, &search_results
), "Fetching third file failed\n");
2236 ok(CHECK_NAME(search_results
.cFileName
), "Invalid third entry - %s\n", search_results
.cFileName
);
2238 SetLastError(0xdeadbeef);
2239 ret
= FindNextFile(handle
, &search_results
);
2240 if (!ret
&& (GetLastError() == ERROR_NO_MORE_FILES
) && (search_ops
== FindExSearchLimitToDirectories
))
2242 skip("File system supports directory filtering\n");
2243 /* Results from the previous call are not cleared */
2244 ok(strcmp(search_results
.cFileName
, "dir1") == 0, "Third entry should be 'dir1' is %s\n", search_results
.cFileName
);
2245 FindClose( handle
);
2249 ok(ret
, "Fetching fourth file failed\n");
2250 ok(CHECK_NAME(search_results
.cFileName
), "Invalid fourth entry - %s\n", search_results
.cFileName
);
2252 ok(FindNextFile(handle
, &search_results
), "Fetching fifth file failed\n");
2253 ok(CHECK_NAME(search_results
.cFileName
), "Invalid fifth entry - %s\n", search_results
.cFileName
);
2257 ok(FindNextFile(handle
, &search_results
) == FALSE
, "Fetching sixth file should fail\n");
2259 FindClose( handle
);
2262 DeleteFileA("test-dir\\file1");
2263 DeleteFileA("test-dir\\file2");
2264 RemoveDirectoryA("test-dir\\dir1");
2265 RemoveDirectoryA("test-dir");
2268 static int test_Mapfile_createtemp(HANDLE
*handle
)
2270 SetFileAttributesA(filename
,FILE_ATTRIBUTE_NORMAL
);
2271 DeleteFile(filename
);
2272 *handle
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, 0,
2273 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2274 if (*handle
!= INVALID_HANDLE_VALUE
) {
2282 static void test_MapFile(void)
2287 ok(test_Mapfile_createtemp(&handle
), "Couldn't create test file.\n");
2289 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0x1000, "named_file_map" );
2290 ok( hmap
!= NULL
, "mapping should work, I named it!\n" );
2292 ok( CloseHandle( hmap
), "can't close mapping handle\n");
2294 /* We have to close file before we try new stuff with mapping again.
2295 Else we would always succeed on XP or block descriptors on 95. */
2296 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0, NULL
);
2297 ok( hmap
!= NULL
, "We should still be able to map!\n" );
2298 ok( CloseHandle( hmap
), "can't close mapping handle\n");
2299 ok( CloseHandle( handle
), "can't close file handle\n");
2302 ok(test_Mapfile_createtemp(&handle
), "Couldn't create test file.\n");
2304 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0, NULL
);
2305 ok( hmap
== NULL
, "mapped zero size file\n");
2306 ok( GetLastError() == ERROR_FILE_INVALID
, "not ERROR_FILE_INVALID\n");
2308 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0x80000000, 0, NULL
);
2309 ok( hmap
== NULL
|| broken(hmap
!= NULL
) /* NT4 */, "mapping should fail\n");
2310 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2312 CloseHandle( hmap
);
2314 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0x80000000, 0x10000, NULL
);
2315 ok( hmap
== NULL
|| broken(hmap
!= NULL
) /* NT4 */, "mapping should fail\n");
2316 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
2318 CloseHandle( hmap
);
2320 /* On XP you can now map again, on Win 95 you cannot. */
2322 ok( CloseHandle( handle
), "can't close file handle\n");
2323 ok( DeleteFileA( filename
), "DeleteFile failed after map\n" );
2326 static void test_GetFileType(void)
2329 HANDLE h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
2330 ok( h
!= INVALID_HANDLE_VALUE
, "open %s failed\n", filename
);
2331 type
= GetFileType(h
);
2332 ok( type
== FILE_TYPE_DISK
, "expected type disk got %d\n", type
);
2334 h
= CreateFileA( "nul", GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
2335 ok( h
!= INVALID_HANDLE_VALUE
, "open nul failed\n" );
2336 type
= GetFileType(h
);
2337 ok( type
== FILE_TYPE_CHAR
, "expected type char for nul got %d\n", type
);
2339 DeleteFileA( filename
);
2342 static int completion_count
;
2344 static void CALLBACK
FileIOComplete(DWORD dwError
, DWORD dwBytes
, LPOVERLAPPED ovl
)
2346 /* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
2347 ReleaseSemaphore(ovl
->hEvent
, 1, NULL
);
2351 static void test_async_file_errors(void)
2353 char szFile
[MAX_PATH
];
2354 HANDLE hSem
= CreateSemaphoreW(NULL
, 1, 1, NULL
);
2356 LPVOID lpBuffer
= HeapAlloc(GetProcessHeap(), 0, 4096);
2358 S(U(ovl
)).Offset
= 0;
2359 S(U(ovl
)).OffsetHigh
= 0;
2361 completion_count
= 0;
2363 GetWindowsDirectoryA(szFile
, sizeof(szFile
)/sizeof(szFile
[0])-1-strlen("\\win.ini"));
2364 strcat(szFile
, "\\win.ini");
2365 hFile
= CreateFileA(szFile
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
2366 NULL
, OPEN_ALWAYS
, FILE_FLAG_OVERLAPPED
, NULL
);
2367 if (hFile
== INVALID_HANDLE_VALUE
) /* win9x doesn't like FILE_SHARE_DELETE */
2368 hFile
= CreateFileA(szFile
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2369 NULL
, OPEN_ALWAYS
, FILE_FLAG_OVERLAPPED
, NULL
);
2370 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA(%s ...) failed\n", szFile
);
2375 while (WaitForSingleObjectEx(hSem
, INFINITE
, TRUE
) == WAIT_IO_COMPLETION
)
2377 res
= ReadFileEx(hFile
, lpBuffer
, 4096, &ovl
, FileIOComplete
);
2378 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
2381 if (!GetOverlappedResult(hFile
, &ovl
, &count
, FALSE
))
2383 S(U(ovl
)).Offset
+= count
;
2384 /* i/o completion routine only called if ReadFileEx returned success.
2385 * we only care about violations of this rule so undo what should have
2389 ok(completion_count
== 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count
);
2390 /*printf("Error = %ld\n", GetLastError());*/
2391 HeapFree(GetProcessHeap(), 0, lpBuffer
);
2394 static BOOL user_apc_ran
;
2395 static void CALLBACK
user_apc(ULONG_PTR param
)
2397 user_apc_ran
= TRUE
;
2400 static void test_read_write(void)
2402 DWORD bytes
, ret
, old_prot
;
2404 char temp_path
[MAX_PATH
];
2405 char filename
[MAX_PATH
];
2407 static const char prefix
[] = "pfx";
2409 ret
= GetTempPathA(MAX_PATH
, temp_path
);
2410 ok(ret
!= 0, "GetTempPathA error %d\n", GetLastError());
2411 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
2413 ret
= GetTempFileNameA(temp_path
, prefix
, 0, filename
);
2414 ok(ret
!= 0, "GetTempFileNameA error %d\n", GetLastError());
2416 hFile
= CreateFileA(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
2417 CREATE_ALWAYS
, FILE_FLAG_RANDOM_ACCESS
, 0);
2418 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA: error %d\n", GetLastError());
2420 user_apc_ran
= FALSE
;
2421 if (pQueueUserAPC
) {
2422 trace("Queueing an user APC\n"); /* verify the file is non alerable */
2423 ret
= pQueueUserAPC(&user_apc
, GetCurrentThread(), 0);
2424 ok(ret
, "QueueUserAPC failed: %d\n", GetLastError());
2427 SetLastError(12345678);
2429 ret
= WriteFile(hFile
, NULL
, 0, &bytes
, NULL
);
2430 ok(ret
&& GetLastError() == 12345678,
2431 "ret = %d, error %d\n", ret
, GetLastError());
2432 ok(!bytes
, "bytes = %d\n", bytes
);
2434 SetLastError(12345678);
2436 ret
= WriteFile(hFile
, NULL
, 10, &bytes
, NULL
);
2437 ok((!ret
&& GetLastError() == ERROR_INVALID_USER_BUFFER
) || /* Win2k */
2438 (ret
&& GetLastError() == 12345678), /* Win9x */
2439 "ret = %d, error %d\n", ret
, GetLastError());
2440 ok(!bytes
|| /* Win2k */
2441 bytes
== 10, /* Win9x */
2442 "bytes = %d\n", bytes
);
2444 /* make sure the file contains data */
2445 WriteFile(hFile
, "this is the test data", 21, &bytes
, NULL
);
2446 SetFilePointer(hFile
, 0, NULL
, FILE_BEGIN
);
2448 SetLastError(12345678);
2450 ret
= ReadFile(hFile
, NULL
, 0, &bytes
, NULL
);
2451 ok(ret
&& GetLastError() == 12345678,
2452 "ret = %d, error %d\n", ret
, GetLastError());
2453 ok(!bytes
, "bytes = %d\n", bytes
);
2455 SetLastError(12345678);
2457 ret
= ReadFile(hFile
, NULL
, 10, &bytes
, NULL
);
2458 ok(!ret
&& (GetLastError() == ERROR_NOACCESS
|| /* Win2k */
2459 GetLastError() == ERROR_INVALID_PARAMETER
), /* Win9x */
2460 "ret = %d, error %d\n", ret
, GetLastError());
2461 ok(!bytes
, "bytes = %d\n", bytes
);
2463 ok(user_apc_ran
== FALSE
, "UserAPC ran, file using alertable io mode\n");
2465 SleepEx(0, TRUE
); /* get rid of apc */
2467 /* test passing protected memory as buffer */
2469 mem
= VirtualAlloc( NULL
, 0x4000, MEM_COMMIT
, PAGE_READWRITE
);
2470 ok( mem
!= NULL
, "failed to allocate virtual mem error %u\n", GetLastError() );
2472 ret
= WriteFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2473 ok( ret
, "WriteFile failed error %u\n", GetLastError() );
2474 ok( bytes
== 0x4000, "only wrote %x bytes\n", bytes
);
2476 ret
= VirtualProtect( mem
+ 0x2000, 0x2000, PAGE_NOACCESS
, &old_prot
);
2477 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
2479 ret
= WriteFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2480 ok( !ret
, "WriteFile succeeded\n" );
2481 ok( GetLastError() == ERROR_INVALID_USER_BUFFER
||
2482 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2483 "wrong error %u\n", GetLastError() );
2484 ok( bytes
== 0, "wrote %x bytes\n", bytes
);
2486 ret
= WriteFile( (HANDLE
)0xdead, mem
, 0x4000, &bytes
, NULL
);
2487 ok( !ret
, "WriteFile succeeded\n" );
2488 ok( GetLastError() == ERROR_INVALID_HANDLE
|| /* handle is checked before buffer on NT */
2489 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2490 "wrong error %u\n", GetLastError() );
2491 ok( bytes
== 0, "wrote %x bytes\n", bytes
);
2493 ret
= VirtualProtect( mem
, 0x2000, PAGE_NOACCESS
, &old_prot
);
2494 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
2496 ret
= WriteFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2497 ok( !ret
, "WriteFile succeeded\n" );
2498 ok( GetLastError() == ERROR_INVALID_USER_BUFFER
||
2499 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2500 "wrong error %u\n", GetLastError() );
2501 ok( bytes
== 0, "wrote %x bytes\n", bytes
);
2503 SetFilePointer( hFile
, 0, NULL
, FILE_BEGIN
);
2505 ret
= ReadFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2506 ok( !ret
, "ReadFile succeeded\n" );
2507 ok( GetLastError() == ERROR_NOACCESS
||
2508 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2509 "wrong error %u\n", GetLastError() );
2510 ok( bytes
== 0, "read %x bytes\n", bytes
);
2512 ret
= VirtualProtect( mem
, 0x2000, PAGE_READONLY
, &old_prot
);
2513 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
2515 ret
= ReadFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2516 ok( !ret
, "ReadFile succeeded\n" );
2517 ok( GetLastError() == ERROR_NOACCESS
||
2518 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2519 "wrong error %u\n", GetLastError() );
2520 ok( bytes
== 0, "read %x bytes\n", bytes
);
2522 ret
= VirtualProtect( mem
, 0x2000, PAGE_READWRITE
, &old_prot
);
2523 ok( ret
, "VirtualProtect failed error %u\n", GetLastError() );
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
);
2532 SetFilePointer( hFile
, 0x1234, NULL
, FILE_BEGIN
);
2533 SetEndOfFile( hFile
);
2534 SetFilePointer( hFile
, 0, NULL
, FILE_BEGIN
);
2536 ret
= ReadFile( hFile
, mem
, 0x4000, &bytes
, NULL
);
2537 ok( !ret
, "ReadFile succeeded\n" );
2538 ok( GetLastError() == ERROR_NOACCESS
||
2539 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2540 "wrong error %u\n", GetLastError() );
2541 ok( bytes
== 0, "read %x bytes\n", bytes
);
2543 ret
= ReadFile( hFile
, mem
, 0x2000, &bytes
, NULL
);
2544 ok( ret
, "ReadFile failed error %u\n", GetLastError() );
2545 ok( bytes
== 0x1234, "read %x bytes\n", bytes
);
2547 ret
= ReadFile( hFile
, NULL
, 1, &bytes
, NULL
);
2548 ok( !ret
, "ReadFile succeeded\n" );
2549 ok( GetLastError() == ERROR_NOACCESS
||
2550 GetLastError() == ERROR_INVALID_PARAMETER
, /* win9x */
2551 "wrong error %u\n", GetLastError() );
2552 ok( bytes
== 0, "read %x bytes\n", bytes
);
2554 VirtualFree( mem
, 0, MEM_FREE
);
2556 ret
= CloseHandle(hFile
);
2557 ok( ret
, "CloseHandle: error %d\n", GetLastError());
2558 ret
= DeleteFileA(filename
);
2559 ok( ret
, "DeleteFileA: error %d\n", GetLastError());
2562 static void test_OpenFile(void)
2569 static const char file
[] = "regedit.exe";
2570 static const char foo
[] = ".\\foo-bar-foo.baz";
2571 static const char *foo_too_long
= ".\\foo-bar-foo.baz+++++++++++++++"
2572 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2573 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2574 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2575 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
2576 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
2577 char buff
[MAX_PATH
];
2578 char buff_long
[4*MAX_PATH
];
2579 char filled_0xA5
[OFS_MAXPATHNAME
];
2583 /* Check for existing file */
2584 if (!pGetSystemWindowsDirectoryA
)
2585 length
= GetWindowsDirectoryA(buff
, MAX_PATH
);
2587 length
= pGetSystemWindowsDirectoryA(buff
, MAX_PATH
);
2589 if (length
+ sizeof(file
) < MAX_PATH
)
2591 p
= buff
+ strlen(buff
);
2592 if (p
> buff
&& p
[-1] != '\\') *p
++ = '\\';
2594 memset(&ofs
, 0xA5, sizeof(ofs
));
2595 SetLastError(0xfaceabee);
2597 hFile
= OpenFile(buff
, &ofs
, OF_EXIST
);
2598 ok( hFile
== TRUE
, "%s not found : %d\n", buff
, GetLastError() );
2599 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2600 "GetLastError() returns %d\n", GetLastError() );
2601 ok( ofs
.cBytes
== sizeof(ofs
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2602 ok( ofs
.nErrCode
== ERROR_SUCCESS
, "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2603 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2604 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2605 ofs
.szPathName
, buff
);
2608 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
2609 length
= GetCurrentDirectoryA(MAX_PATH
, buff
);
2611 /* Check for nonexistent file */
2612 if (length
+ sizeof(foo
) < MAX_PATH
)
2614 p
= buff
+ strlen(buff
);
2615 if (p
> buff
&& p
[-1] != '\\') *p
++ = '\\';
2616 strcpy( p
, foo
+ 2 );
2617 memset(&ofs
, 0xA5, sizeof(ofs
));
2618 SetLastError(0xfaceabee);
2620 hFile
= OpenFile(foo
, &ofs
, OF_EXIST
);
2621 ok( hFile
== HFILE_ERROR
, "hFile != HFILE_ERROR : %d\n", GetLastError());
2622 ok( GetLastError() == ERROR_FILE_NOT_FOUND
, "GetLastError() returns %d\n", GetLastError() );
2624 ok( ofs
.cBytes
== 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2625 ok( ofs
.nErrCode
== ERROR_FILE_NOT_FOUND
, "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2626 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0 || strncmp(ofs
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0,
2627 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
2628 ofs
.szPathName
, buff
);
2631 length
= GetCurrentDirectoryA(MAX_PATH
, buff_long
);
2632 length
+= lstrlenA(foo_too_long
+ 1);
2634 /* Check for nonexistent file with too long filename */
2635 if (length
>= OFS_MAXPATHNAME
&& length
< sizeof(buff_long
))
2637 lstrcatA(buff_long
, foo_too_long
+ 1); /* Avoid '.' during concatenation */
2638 memset(&ofs
, 0xA5, sizeof(ofs
));
2639 SetLastError(0xfaceabee);
2641 hFile
= OpenFile(foo_too_long
, &ofs
, OF_EXIST
);
2642 ok( hFile
== HFILE_ERROR
, "hFile != HFILE_ERROR : %d\n", GetLastError());
2643 ok( GetLastError() == ERROR_INVALID_DATA
|| GetLastError() == ERROR_FILENAME_EXCED_RANGE
,
2644 "GetLastError() returns %d\n", GetLastError() );
2646 ok( ofs
.cBytes
== 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2647 ok( ofs
.nErrCode
== ERROR_INVALID_DATA
|| ofs
.nErrCode
== ERROR_FILENAME_EXCED_RANGE
,
2648 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2649 ok( strncmp(ofs
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0,
2650 "OpenFile returned '%s', but was expected to return string filled with 0xA5\n",
2654 length
= GetCurrentDirectoryA(MAX_PATH
, buff
) + sizeof(filename
);
2656 if (length
>= MAX_PATH
)
2658 trace("Buffer too small, requested length = %d, but MAX_PATH = %d. Skipping test.\n", length
, MAX_PATH
);
2661 p
= buff
+ strlen(buff
);
2662 if (p
> buff
&& p
[-1] != '\\') *p
++ = '\\';
2663 strcpy( p
, filename
);
2665 memset(&ofs
, 0xA5, sizeof(ofs
));
2666 SetLastError(0xfaceabee);
2667 /* Create an empty file */
2668 hFile
= OpenFile(filename
, &ofs
, OF_CREATE
);
2669 ok( hFile
!= HFILE_ERROR
, "OpenFile failed to create nonexistent file\n" );
2670 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2671 "GetLastError() returns %d\n", GetLastError() );
2672 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2673 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2674 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2675 ret
= _lclose(hFile
);
2676 ok( !ret
, "_lclose() returns %d\n", ret
);
2677 retval
= GetFileAttributesA(filename
);
2678 ok( retval
!= INVALID_FILE_ATTRIBUTES
, "GetFileAttributesA: error %d\n", GetLastError() );
2680 memset(&ofs
, 0xA5, sizeof(ofs
));
2681 SetLastError(0xfaceabee);
2682 /* Check various opening options: */
2683 /* for reading only, */
2684 hFile
= OpenFile(filename
, &ofs
, OF_READ
);
2685 ok( hFile
!= HFILE_ERROR
, "OpenFile failed on read\n" );
2686 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2687 "GetLastError() returns %d\n", GetLastError() );
2688 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2689 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2690 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2691 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2692 "OpenFile returned '%s', but was expected to return '%s'\n", ofs
.szPathName
, buff
);
2693 ret
= _lclose(hFile
);
2694 ok( !ret
, "_lclose() returns %d\n", ret
);
2696 memset(&ofs
, 0xA5, sizeof(ofs
));
2697 SetLastError(0xfaceabee);
2698 /* for writing only, */
2699 hFile
= OpenFile(filename
, &ofs
, OF_WRITE
);
2700 ok( hFile
!= HFILE_ERROR
, "OpenFile failed on write\n" );
2701 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2702 "GetLastError() returns %d\n", GetLastError() );
2703 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2704 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2705 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2706 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2707 "OpenFile returned '%s', but was expected to return '%s'\n", ofs
.szPathName
, buff
);
2708 ret
= _lclose(hFile
);
2709 ok( !ret
, "_lclose() returns %d\n", ret
);
2711 memset(&ofs
, 0xA5, sizeof(ofs
));
2712 SetLastError(0xfaceabee);
2713 /* for reading and writing, */
2714 hFile
= OpenFile(filename
, &ofs
, OF_READWRITE
);
2715 ok( hFile
!= HFILE_ERROR
, "OpenFile failed on read/write\n" );
2716 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2717 "GetLastError() returns %d\n", GetLastError() );
2718 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2719 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2720 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2721 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2722 "OpenFile returned '%s', but was expected to return '%s'\n", ofs
.szPathName
, buff
);
2723 ret
= _lclose(hFile
);
2724 ok( !ret
, "_lclose() returns %d\n", ret
);
2726 memset(&ofs
, 0xA5, sizeof(ofs
));
2727 SetLastError(0xfaceabee);
2728 /* for checking file presence. */
2729 hFile
= OpenFile(filename
, &ofs
, OF_EXIST
);
2730 ok( hFile
== 1, "OpenFile failed on finding our created file\n" );
2731 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2732 "GetLastError() returns %d\n", GetLastError() );
2733 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2734 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2735 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2736 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2737 "OpenFile returned '%s', but was expected to return '%s'\n", ofs
.szPathName
, buff
);
2739 memset(&ofs
, 0xA5, sizeof(ofs
));
2740 SetLastError(0xfaceabee);
2741 /* Delete the file and make sure it doesn't exist anymore */
2742 hFile
= OpenFile(filename
, &ofs
, OF_DELETE
);
2743 ok( hFile
== 1, "OpenFile failed on delete (%d)\n", hFile
);
2744 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS
,
2745 "GetLastError() returns %d\n", GetLastError() );
2746 ok( ofs
.cBytes
== sizeof(OFSTRUCT
), "OpenFile set ofs.cBytes to %d\n", ofs
.cBytes
);
2747 ok( ofs
.nErrCode
== ERROR_SUCCESS
|| broken(ofs
.nErrCode
!= ERROR_SUCCESS
) /* win9x */,
2748 "OpenFile set ofs.nErrCode to %d\n", ofs
.nErrCode
);
2749 ok( lstrcmpiA(ofs
.szPathName
, buff
) == 0,
2750 "OpenFile returned '%s', but was expected to return '%s'\n", ofs
.szPathName
, buff
);
2752 retval
= GetFileAttributesA(filename
);
2753 ok( retval
== INVALID_FILE_ATTRIBUTES
, "GetFileAttributesA succeeded on deleted file\n" );
2756 static void test_overlapped(void)
2761 /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
2762 if (0) /* tested: WinXP */
2764 GetOverlappedResult(0, NULL
, &result
, FALSE
);
2765 GetOverlappedResult(0, &ov
, NULL
, FALSE
);
2766 GetOverlappedResult(0, NULL
, NULL
, FALSE
);
2769 memset( &ov
, 0, sizeof ov
);
2771 r
= GetOverlappedResult(0, &ov
, &result
, 0);
2773 ok( result
== 0, "wrong result %u\n", result
);
2775 ok( GetLastError() == ERROR_INVALID_HANDLE
, "wrong error %u\n", GetLastError() );
2779 ov
.InternalHigh
= 0xabcd;
2780 r
= GetOverlappedResult(0, &ov
, &result
, 0);
2782 ok( result
== 0xabcd, "wrong result %u\n", result
);
2784 ok( GetLastError() == ERROR_INVALID_HANDLE
, "wrong error %u\n", GetLastError() );
2786 SetLastError( 0xb00 );
2788 ov
.Internal
= STATUS_INVALID_HANDLE
;
2789 ov
.InternalHigh
= 0xabcd;
2790 r
= GetOverlappedResult(0, &ov
, &result
, 0);
2791 ok( GetLastError() == ERROR_INVALID_HANDLE
, "wrong error %u\n", GetLastError() );
2792 ok( r
== FALSE
, "should return false\n");
2793 ok( result
== 0xabcd || result
== 0 /* win9x */, "wrong result %u\n", result
);
2795 SetLastError( 0xb00 );
2797 ov
.Internal
= STATUS_PENDING
;
2798 ov
.InternalHigh
= 0xabcd;
2799 r
= GetOverlappedResult(0, &ov
, &result
, 0);
2800 ok( GetLastError() == ERROR_IO_INCOMPLETE
|| GetLastError() == ERROR_INVALID_HANDLE
/* win9x */,
2801 "wrong error %u\n", GetLastError() );
2802 ok( r
== FALSE
, "should return false\n");
2803 ok( result
== 0, "wrong result %u\n", result
);
2805 SetLastError( 0xb00 );
2806 ov
.hEvent
= CreateEvent( NULL
, 1, 1, NULL
);
2807 ov
.Internal
= STATUS_PENDING
;
2808 ov
.InternalHigh
= 0xabcd;
2809 r
= GetOverlappedResult(0, &ov
, &result
, 0);
2810 ok( GetLastError() == ERROR_IO_INCOMPLETE
|| GetLastError() == ERROR_INVALID_HANDLE
/* win9x */,
2811 "wrong error %u\n", GetLastError() );
2812 ok( r
== FALSE
, "should return false\n");
2814 ResetEvent( ov
.hEvent
);
2816 SetLastError( 0xb00 );
2817 ov
.Internal
= STATUS_PENDING
;
2818 ov
.InternalHigh
= 0;
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");
2824 r
= CloseHandle( ov
.hEvent
);
2825 ok( r
== TRUE
, "close handle failed\n");
2828 static void test_RemoveDirectory(void)
2831 char directory
[] = "removeme";
2833 rc
= CreateDirectory(directory
, NULL
);
2834 ok( rc
, "Createdirectory failed, gle=%d\n", GetLastError() );
2836 rc
= SetCurrentDirectory(directory
);
2837 ok( rc
, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2839 rc
= RemoveDirectory(".");
2842 rc
= SetCurrentDirectory("..");
2843 ok( rc
, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
2845 rc
= RemoveDirectory(directory
);
2846 ok( rc
, "RemoveDirectory failed, gle=%d\n", GetLastError() );
2850 static BOOL
check_file_time( const FILETIME
*ft1
, const FILETIME
*ft2
, UINT tolerance
)
2852 ULONGLONG t1
= ((ULONGLONG
)ft1
->dwHighDateTime
<< 32) | ft1
->dwLowDateTime
;
2853 ULONGLONG t2
= ((ULONGLONG
)ft2
->dwHighDateTime
<< 32) | ft2
->dwLowDateTime
;
2854 return abs(t1
- t2
) <= tolerance
;
2857 static void test_ReplaceFileA(void)
2859 char replaced
[MAX_PATH
], replacement
[MAX_PATH
], backup
[MAX_PATH
];
2860 HANDLE hReplacedFile
, hReplacementFile
, hBackupFile
;
2861 static const char replacedData
[] = "file-to-replace";
2862 static const char replacementData
[] = "new-file";
2863 static const char backupData
[] = "backup-file";
2864 FILETIME ftReplaced
, ftReplacement
, ftBackup
;
2865 static const char prefix
[] = "pfx";
2866 char temp_path
[MAX_PATH
];
2868 BOOL retok
, removeBackup
= FALSE
;
2872 win_skip("ReplaceFileA() is missing\n");
2876 ret
= GetTempPathA(MAX_PATH
, temp_path
);
2877 ok(ret
!= 0, "GetTempPathA error %d\n", GetLastError());
2878 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
2880 ret
= GetTempFileNameA(temp_path
, prefix
, 0, replaced
);
2881 ok(ret
!= 0, "GetTempFileNameA error (replaced) %d\n", GetLastError());
2883 ret
= GetTempFileNameA(temp_path
, prefix
, 0, replacement
);
2884 ok(ret
!= 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2886 ret
= GetTempFileNameA(temp_path
, prefix
, 0, backup
);
2887 ok(ret
!= 0, "GetTempFileNameA error (backup) %d\n", GetLastError());
2889 /* place predictable data in the file to be replaced */
2890 hReplacedFile
= CreateFileA(replaced
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
2891 ok(hReplacedFile
!= INVALID_HANDLE_VALUE
,
2892 "failed to open replaced file\n");
2893 retok
= WriteFile(hReplacedFile
, replacedData
, sizeof(replacedData
), &ret
, NULL
);
2894 ok( retok
&& ret
== sizeof(replacedData
),
2895 "WriteFile error (replaced) %d\n", GetLastError());
2896 ok(GetFileSize(hReplacedFile
, NULL
) == sizeof(replacedData
),
2897 "replaced file has wrong size\n");
2898 /* place predictable data in the file to be the replacement */
2899 hReplacementFile
= CreateFileA(replacement
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
2900 ok(hReplacementFile
!= INVALID_HANDLE_VALUE
,
2901 "failed to open replacement file\n");
2902 retok
= WriteFile(hReplacementFile
, replacementData
, sizeof(replacementData
), &ret
, NULL
);
2903 ok( retok
&& ret
== sizeof(replacementData
),
2904 "WriteFile error (replacement) %d\n", GetLastError());
2905 ok(GetFileSize(hReplacementFile
, NULL
) == sizeof(replacementData
),
2906 "replacement file has wrong size\n");
2907 /* place predictable data in the backup file (to be over-written) */
2908 hBackupFile
= CreateFileA(backup
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
2909 ok(hBackupFile
!= INVALID_HANDLE_VALUE
,
2910 "failed to open backup file\n");
2911 retok
= WriteFile(hBackupFile
, backupData
, sizeof(backupData
), &ret
, NULL
);
2912 ok( retok
&& ret
== sizeof(backupData
),
2913 "WriteFile error (replacement) %d\n", GetLastError());
2914 ok(GetFileSize(hBackupFile
, NULL
) == sizeof(backupData
),
2915 "backup file has wrong size\n");
2916 /* change the filetime on the "replaced" file to ensure that it changes */
2917 ret
= GetFileTime(hReplacedFile
, NULL
, NULL
, &ftReplaced
);
2918 ok( ret
, "GetFileTime error (replaced) %d\n", GetLastError());
2919 ftReplaced
.dwLowDateTime
-= 600000000; /* 60 second */
2920 ret
= SetFileTime(hReplacedFile
, NULL
, NULL
, &ftReplaced
);
2921 ok( ret
, "SetFileTime error (replaced) %d\n", GetLastError());
2922 GetFileTime(hReplacedFile
, NULL
, NULL
, &ftReplaced
); /* get the actual time back */
2923 CloseHandle(hReplacedFile
);
2924 /* change the filetime on the backup to ensure that it changes */
2925 ret
= GetFileTime(hBackupFile
, NULL
, NULL
, &ftBackup
);
2926 ok( ret
, "GetFileTime error (backup) %d\n", GetLastError());
2927 ftBackup
.dwLowDateTime
-= 1200000000; /* 120 second */
2928 ret
= SetFileTime(hBackupFile
, NULL
, NULL
, &ftBackup
);
2929 ok( ret
, "SetFileTime error (backup) %d\n", GetLastError());
2930 GetFileTime(hBackupFile
, NULL
, NULL
, &ftBackup
); /* get the actual time back */
2931 CloseHandle(hBackupFile
);
2932 /* get the filetime on the replacement file to perform checks */
2933 ret
= GetFileTime(hReplacementFile
, NULL
, NULL
, &ftReplacement
);
2934 ok( ret
, "GetFileTime error (replacement) %d\n", GetLastError());
2935 CloseHandle(hReplacementFile
);
2937 /* perform replacement w/ backup
2938 * TODO: flags are not implemented
2940 SetLastError(0xdeadbeef);
2941 ret
= pReplaceFileA(replaced
, replacement
, backup
, 0, 0, 0);
2942 ok(ret
, "ReplaceFileA: unexpected error %d\n", GetLastError());
2943 /* make sure that the backup has the size of the old "replaced" file */
2944 hBackupFile
= CreateFileA(backup
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2945 ok(hBackupFile
!= INVALID_HANDLE_VALUE
,
2946 "failed to open backup file\n");
2947 ret
= GetFileSize(hBackupFile
, NULL
);
2948 ok(ret
== sizeof(replacedData
),
2949 "backup file has wrong size %d\n", ret
);
2950 /* make sure that the "replaced" file has the size of the replacement file */
2951 hReplacedFile
= CreateFileA(replaced
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2952 ok(hReplacedFile
!= INVALID_HANDLE_VALUE
,
2953 "failed to open replaced file: %d\n", GetLastError());
2954 if (hReplacedFile
!= INVALID_HANDLE_VALUE
)
2956 ret
= GetFileSize(hReplacedFile
, NULL
);
2957 ok(ret
== sizeof(replacementData
),
2958 "replaced file has wrong size %d\n", ret
);
2959 /* make sure that the replacement file no-longer exists */
2960 hReplacementFile
= CreateFileA(replacement
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
2961 ok(hReplacementFile
== INVALID_HANDLE_VALUE
,
2962 "unexpected error, replacement file should not exist %d\n", GetLastError());
2963 /* make sure that the backup has the old "replaced" filetime */
2964 ret
= GetFileTime(hBackupFile
, NULL
, NULL
, &ftBackup
);
2965 ok( ret
, "GetFileTime error (backup %d\n", GetLastError());
2966 ok(check_file_time(&ftBackup
, &ftReplaced
, 20000000), "backup file has wrong filetime\n");
2967 CloseHandle(hBackupFile
);
2968 /* make sure that the "replaced" has the old replacement filetime */
2969 ret
= GetFileTime(hReplacedFile
, NULL
, NULL
, &ftReplaced
);
2970 ok( ret
, "GetFileTime error (backup %d\n", GetLastError());
2971 ok(check_file_time(&ftReplaced
, &ftReplacement
, 20000000),
2972 "replaced file has wrong filetime %x%08x / %x%08x\n",
2973 ftReplaced
.dwHighDateTime
, ftReplaced
.dwLowDateTime
,
2974 ftReplacement
.dwHighDateTime
, ftReplacement
.dwLowDateTime
);
2975 CloseHandle(hReplacedFile
);
2978 skip("couldn't open replacement file, skipping tests\n");
2980 /* re-create replacement file for pass w/o backup (blank) */
2981 ret
= GetTempFileNameA(temp_path
, prefix
, 0, replacement
);
2982 ok(ret
!= 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2983 /* perform replacement w/o backup
2984 * TODO: flags are not implemented
2986 SetLastError(0xdeadbeef);
2987 ret
= pReplaceFileA(replaced
, replacement
, NULL
, 0, 0, 0);
2988 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
2989 "ReplaceFileA: unexpected error %d\n", GetLastError());
2991 /* re-create replacement file for pass w/ backup (backup-file not existing) */
2992 ret
= GetTempFileNameA(temp_path
, prefix
, 0, replacement
);
2993 ok(ret
!= 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
2994 ret
= DeleteFileA(backup
);
2995 ok(ret
, "DeleteFileA: error (backup) %d\n", GetLastError());
2996 /* perform replacement w/ backup (no pre-existing backup)
2997 * TODO: flags are not implemented
2999 SetLastError(0xdeadbeef);
3000 ret
= pReplaceFileA(replaced
, replacement
, backup
, 0, 0, 0);
3001 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3002 "ReplaceFileA: unexpected error %d\n", GetLastError());
3004 removeBackup
= TRUE
;
3006 /* re-create replacement file for pass w/ no permissions to "replaced" */
3007 ret
= GetTempFileNameA(temp_path
, prefix
, 0, replacement
);
3008 ok(ret
!= 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3009 ret
= SetFileAttributesA(replaced
, FILE_ATTRIBUTE_READONLY
);
3010 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3011 "SetFileAttributesA: error setting to read only %d\n", GetLastError());
3012 /* perform replacement w/ backup (no permission to "replaced")
3013 * TODO: flags are not implemented
3015 SetLastError(0xdeadbeef);
3016 ret
= pReplaceFileA(replaced
, replacement
, backup
, 0, 0, 0);
3017 ok(ret
!= ERROR_UNABLE_TO_REMOVE_REPLACED
, "ReplaceFileA: unexpected error %d\n", GetLastError());
3018 /* make sure that the replacement file still exists */
3019 hReplacementFile
= CreateFileA(replacement
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
3020 ok(hReplacementFile
!= INVALID_HANDLE_VALUE
||
3021 broken(GetLastError() == ERROR_FILE_NOT_FOUND
), /* win2k */
3022 "unexpected error, replacement file should still exist %d\n", GetLastError());
3023 CloseHandle(hReplacementFile
);
3024 ret
= SetFileAttributesA(replaced
, FILE_ATTRIBUTE_NORMAL
);
3025 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3026 "SetFileAttributesA: error setting to normal %d\n", GetLastError());
3028 /* replacement file still exists, make pass w/o "replaced" */
3029 ret
= DeleteFileA(replaced
);
3030 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3031 "DeleteFileA: error (replaced) %d\n", GetLastError());
3032 /* perform replacement w/ backup (no pre-existing backup or "replaced")
3033 * TODO: flags are not implemented
3035 SetLastError(0xdeadbeef);
3036 ret
= pReplaceFileA(replaced
, replacement
, backup
, 0, 0, 0);
3037 ok(!ret
&& (GetLastError() == ERROR_FILE_NOT_FOUND
||
3038 GetLastError() == ERROR_ACCESS_DENIED
),
3039 "ReplaceFileA: unexpected error %d\n", GetLastError());
3041 /* perform replacement w/o existing "replacement" file
3042 * TODO: flags are not implemented
3044 SetLastError(0xdeadbeef);
3045 ret
= pReplaceFileA(replaced
, replacement
, NULL
, 0, 0, 0);
3046 ok(!ret
&& (GetLastError() == ERROR_FILE_NOT_FOUND
||
3047 GetLastError() == ERROR_ACCESS_DENIED
),
3048 "ReplaceFileA: unexpected error %d\n", GetLastError());
3049 DeleteFileA( replacement
);
3052 * if the first round (w/ backup) worked then as long as there is no
3053 * failure then there is no need to check this round (w/ backup is the
3054 * more complete case)
3057 /* delete temporary files, replacement and replaced are already deleted */
3060 ret
= DeleteFileA(backup
);
3062 broken(GetLastError() == ERROR_ACCESS_DENIED
), /* win2k */
3063 "DeleteFileA: error (backup) %d\n", GetLastError());
3068 * ReplaceFileW is a simpler case of ReplaceFileA, there is no
3069 * need to be as thorough.
3071 static void test_ReplaceFileW(void)
3073 WCHAR replaced
[MAX_PATH
], replacement
[MAX_PATH
], backup
[MAX_PATH
];
3074 static const WCHAR prefix
[] = {'p','f','x',0};
3075 WCHAR temp_path
[MAX_PATH
];
3077 BOOL removeBackup
= FALSE
;
3081 win_skip("ReplaceFileW() is missing\n");
3085 ret
= GetTempPathW(MAX_PATH
, temp_path
);
3086 if (ret
== 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
3088 win_skip("GetTempPathW is not available\n");
3091 ok(ret
!= 0, "GetTempPathW error %d\n", GetLastError());
3092 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
3094 ret
= GetTempFileNameW(temp_path
, prefix
, 0, replaced
);
3095 ok(ret
!= 0, "GetTempFileNameW error (replaced) %d\n", GetLastError());
3097 ret
= GetTempFileNameW(temp_path
, prefix
, 0, replacement
);
3098 ok(ret
!= 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3100 ret
= GetTempFileNameW(temp_path
, prefix
, 0, backup
);
3101 ok(ret
!= 0, "GetTempFileNameW error (backup) %d\n", GetLastError());
3103 ret
= pReplaceFileW(replaced
, replacement
, backup
, 0, 0, 0);
3104 ok(ret
, "ReplaceFileW: error %d\n", GetLastError());
3106 ret
= GetTempFileNameW(temp_path
, prefix
, 0, replacement
);
3107 ok(ret
!= 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3108 ret
= pReplaceFileW(replaced
, replacement
, NULL
, 0, 0, 0);
3109 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3110 "ReplaceFileW: error %d\n", GetLastError());
3112 ret
= GetTempFileNameW(temp_path
, prefix
, 0, replacement
);
3113 ok(ret
!= 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3114 ret
= DeleteFileW(backup
);
3115 ok(ret
, "DeleteFileW: error (backup) %d\n", GetLastError());
3116 ret
= pReplaceFileW(replaced
, replacement
, backup
, 0, 0, 0);
3117 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3118 "ReplaceFileW: error %d\n", GetLastError());
3120 ret
= GetTempFileNameW(temp_path
, prefix
, 0, replacement
);
3121 ok(ret
!= 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3122 ret
= SetFileAttributesW(replaced
, FILE_ATTRIBUTE_READONLY
);
3123 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3124 "SetFileAttributesW: error setting to read only %d\n", GetLastError());
3126 ret
= pReplaceFileW(replaced
, replacement
, backup
, 0, 0, 0);
3127 ok(ret
!= ERROR_UNABLE_TO_REMOVE_REPLACED
,
3128 "ReplaceFileW: unexpected error %d\n", GetLastError());
3129 ret
= SetFileAttributesW(replaced
, FILE_ATTRIBUTE_NORMAL
);
3130 ok(ret
|| GetLastError() == ERROR_ACCESS_DENIED
,
3131 "SetFileAttributesW: error setting to normal %d\n", GetLastError());
3133 removeBackup
= TRUE
;
3135 ret
= DeleteFileW(replaced
);
3136 ok(ret
, "DeleteFileW: error (replaced) %d\n", GetLastError());
3137 ret
= pReplaceFileW(replaced
, replacement
, backup
, 0, 0, 0);
3138 ok(!ret
, "ReplaceFileW: error %d\n", GetLastError());
3140 ret
= pReplaceFileW(replaced
, replacement
, NULL
, 0, 0, 0);
3141 ok(!ret
&& (GetLastError() == ERROR_FILE_NOT_FOUND
||
3142 GetLastError() == ERROR_ACCESS_DENIED
),
3143 "ReplaceFileW: unexpected error %d\n", GetLastError());
3144 DeleteFileW( replacement
);
3148 ret
= DeleteFileW(backup
);
3150 broken(GetLastError() == ERROR_ACCESS_DENIED
), /* win2k */
3151 "DeleteFileW: error (backup) %d\n", GetLastError());
3157 InitFunctionPointers();
3167 test_GetTempFileNameA();
3176 test_FindFirstFileA();
3177 test_FindNextFileA();
3178 test_FindFirstFileExA(0);
3179 /* FindExLimitToDirectories is ignored if the file system doesn't support directory filtering */
3180 test_FindFirstFileExA(FindExSearchLimitToDirectories
);
3182 test_file_sharing();
3183 test_offset_in_overlapped_structure();
3186 test_async_file_errors();
3190 test_RemoveDirectory();
3191 test_ReplaceFileA();
3192 test_ReplaceFileW();