2 * Unit tests for file functions in Wine
4 * Copyright (c) 2002, 2004 Jakob Eriksson
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include "wine/test.h"
31 static int dll_capable(const char *dll
, const char *function
)
33 HMODULE module
= GetModuleHandleA(dll
);
34 if (!module
) return 0;
36 return (GetProcAddress(module
, function
) != NULL
);
40 LPCSTR filename
= "testfile.xxx";
42 "en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
43 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
44 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
45 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
46 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
47 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
48 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
49 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
50 "1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
51 "sdlkfjasdlkfj a dslkj adsklf \n \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
54 static void test__hread( void )
63 SetFileAttributesA(filename
,FILE_ATTRIBUTE_NORMAL
); /* be sure to remove stale files */
64 DeleteFileA( filename
);
65 filehandle
= _lcreat( filename
, 0 );
66 if (filehandle
== HFILE_ERROR
)
68 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
72 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
74 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
76 filehandle
= _lopen( filename
, OF_READ
);
78 ok( HFILE_ERROR
!= filehandle
, "couldn't open file \"%s\" again (err=%ld)\n", filename
, GetLastError( ) );
80 bytes_read
= _hread( filehandle
, buffer
, 2 * strlen( sillytext
) );
82 ok( lstrlenA( sillytext
) == bytes_read
, "file read size error\n" );
84 for (bytes_wanted
= 0; bytes_wanted
< lstrlenA( sillytext
); bytes_wanted
++)
86 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
87 ok( _hread( filehandle
, buffer
, bytes_wanted
) == bytes_wanted
, "erratic _hread return value\n" );
88 for (i
= 0; i
< bytes_wanted
; i
++)
90 ok( buffer
[i
] == sillytext
[i
], "that's not what's written\n" );
94 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
96 ret
= DeleteFileA( filename
);
97 ok( ret
!= 0, "DeleteFile failed (%ld)\n", GetLastError( ) );
101 static void test__hwrite( void )
110 HLOCAL memory_object
;
114 filehandle
= _lcreat( filename
, 0 );
115 if (filehandle
== HFILE_ERROR
)
117 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
121 ok( HFILE_ERROR
!= _hwrite( filehandle
, "", 0 ), "_hwrite complains\n" );
123 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
125 filehandle
= _lopen( filename
, OF_READ
);
127 bytes_read
= _hread( filehandle
, buffer
, 1);
129 ok( 0 == bytes_read
, "file read size error\n" );
131 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
133 filehandle
= _lopen( filename
, OF_READWRITE
);
137 srand( (unsigned)time( NULL
) );
138 for (blocks
= 0; blocks
< 100; blocks
++)
140 for (i
= 0; i
< (long)sizeof( buffer
); i
++)
143 checksum
[0] = checksum
[0] + buffer
[i
];
145 ok( HFILE_ERROR
!= _hwrite( filehandle
, buffer
, sizeof( buffer
) ), "_hwrite complains\n" );
146 bytes_written
= bytes_written
+ sizeof( buffer
);
149 ok( HFILE_ERROR
!= _hwrite( filehandle
, checksum
, 1 ), "_hwrite complains\n" );
152 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
154 memory_object
= LocalAlloc( LPTR
, bytes_written
);
156 ok( 0 != memory_object
, "LocalAlloc fails. (Could be out of memory.)\n" );
158 contents
= LocalLock( memory_object
);
160 filehandle
= _lopen( filename
, OF_READ
);
162 contents
= LocalLock( memory_object
);
164 ok( NULL
!= contents
, "LocalLock whines\n" );
166 ok( bytes_written
== _hread( filehandle
, contents
, bytes_written
), "read length differ from write length\n" );
172 checksum
[0] = checksum
[0] + contents
[i
];
175 while (i
< bytes_written
- 1);
177 ok( checksum
[0] == contents
[i
], "stored checksum differ from computed checksum\n" );
179 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
181 ret
= DeleteFileA( filename
);
182 ok( ret
!= 0, "DeleteFile failed (%ld)\n", GetLastError( ) );
186 static void test__lclose( void )
191 filehandle
= _lcreat( filename
, 0 );
192 if (filehandle
== HFILE_ERROR
)
194 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
198 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
200 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
202 ret
= DeleteFileA( filename
);
203 ok( ret
!= 0, "DeleteFile failed (%ld)\n", GetLastError( ) );
207 static void test__lcreat( void )
211 WIN32_FIND_DATAA search_results
;
212 char slashname
[] = "testfi/";
217 filehandle
= _lcreat( filename
, 0 );
218 if (filehandle
== HFILE_ERROR
)
220 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
224 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
226 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
228 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
230 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
232 ok( INVALID_HANDLE_VALUE
!= FindFirstFileA( filename
, &search_results
), "should be able to find file\n" );
234 ret
= DeleteFileA(filename
);
235 ok( ret
!= 0, "DeleteFile failed (%ld)\n", GetLastError());
237 filehandle
= _lcreat( filename
, 1 ); /* readonly */
238 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%ld)\n", filename
, GetLastError( ) );
240 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite shouldn't be able to write never the less\n" );
242 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
244 ok( INVALID_HANDLE_VALUE
!= FindFirstFileA( filename
, &search_results
), "should be able to find file\n" );
246 ok( 0 == DeleteFileA( filename
), "shouldn't be able to delete a readonly file\n" );
248 ok( SetFileAttributesA(filename
, FILE_ATTRIBUTE_NORMAL
) != 0, "couldn't change attributes on file\n" );
250 ok( DeleteFileA( filename
) != 0, "now it should be possible to delete the file!\n" );
252 filehandle
= _lcreat( filename
, 2 );
253 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%ld)\n", filename
, GetLastError( ) );
255 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
257 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
259 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
261 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
263 ok( INVALID_HANDLE_VALUE
!= FindFirstFileA( filename
, &search_results
), "should STILL be able to find file\n" );
265 ret
= DeleteFileA( filename
);
266 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
268 filehandle
= _lcreat( filename
, 4 ); /* SYSTEM file */
269 ok( HFILE_ERROR
!= filehandle
, "couldn't create file \"%s\" (err=%ld)\n", filename
, GetLastError( ) );
271 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
273 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
275 ok( _hread( filehandle
, buffer
, strlen( sillytext
) ) == lstrlenA( sillytext
), "erratic _hread return value\n" );
277 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
279 ok( INVALID_HANDLE_VALUE
!= FindFirstFileA( filename
, &search_results
), "should STILL be able to find file\n" );
281 ret
= DeleteFileA( filename
);
282 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
284 filehandle
=_lcreat (slashname
, 0); /* illegal name */
285 if (HFILE_ERROR
==filehandle
) {
287 ok (err
==ERROR_INVALID_NAME
|| err
==ERROR_PATH_NOT_FOUND
,
288 "creating file \"%s\" failed with error %d\n", slashname
, err
);
289 } else { /* only NT succeeds */
291 find
=FindFirstFileA (slashname
, &search_results
);
292 if (INVALID_HANDLE_VALUE
!=find
)
294 ret
= FindClose (find
);
295 ok (0 != ret
, "FindClose complains (%ld)\n", GetLastError ());
296 slashname
[strlen(slashname
)-1]=0;
297 ok (!strcmp (slashname
, search_results
.cFileName
),
298 "found unexpected name \"%s\"\n", search_results
.cFileName
);
299 ok (FILE_ATTRIBUTE_ARCHIVE
==search_results
.dwFileAttributes
,
300 "attributes of file \"%s\" are 0x%04lx\n", search_results
.cFileName
,
301 search_results
.dwFileAttributes
);
303 ret
= DeleteFileA( slashname
);
304 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
307 filehandle
=_lcreat (filename
, 8); /* illegal attribute */
308 if (HFILE_ERROR
==filehandle
)
309 ok (0, "couldn't create volume label \"%s\"\n", filename
);
312 find
=FindFirstFileA (filename
, &search_results
);
313 if (INVALID_HANDLE_VALUE
==find
)
314 ok (0, "file \"%s\" not found\n", filename
);
316 ret
= FindClose(find
);
317 ok ( 0 != ret
, "FindClose complains (%ld)\n", GetLastError ());
318 ok (!strcmp (filename
, search_results
.cFileName
),
319 "found unexpected name \"%s\"\n", search_results
.cFileName
);
320 ok (FILE_ATTRIBUTE_ARCHIVE
==search_results
.dwFileAttributes
,
321 "attributes of file \"%s\" are 0x%04lx\n", search_results
.cFileName
,
322 search_results
.dwFileAttributes
);
324 ret
= DeleteFileA( filename
);
325 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
330 static void test__llseek( void )
338 filehandle
= _lcreat( filename
, 0 );
339 if (filehandle
== HFILE_ERROR
)
341 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
345 for (i
= 0; i
< 400; i
++)
347 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
349 ok( HFILE_ERROR
!= _llseek( filehandle
, 400 * strlen( sillytext
), FILE_CURRENT
), "should be able to seek\n" );
350 ok( HFILE_ERROR
!= _llseek( filehandle
, 27 + 35 * strlen( sillytext
), FILE_BEGIN
), "should be able to seek\n" );
352 bytes_read
= _hread( filehandle
, buffer
, 1);
353 ok( 1 == bytes_read
, "file read size error\n" );
354 ok( buffer
[0] == sillytext
[27], "_llseek error, it got lost seeking\n" );
355 ok( HFILE_ERROR
!= _llseek( filehandle
, -400 * strlen( sillytext
), FILE_END
), "should be able to seek\n" );
357 bytes_read
= _hread( filehandle
, buffer
, 1);
358 ok( 1 == bytes_read
, "file read size error\n" );
359 ok( buffer
[0] == sillytext
[0], "_llseek error, it got lost seeking\n" );
360 ok( HFILE_ERROR
!= _llseek( filehandle
, 1000000, FILE_END
), "should be able to seek past file; poor, poor Windows programmers\n" );
361 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
363 ret
= DeleteFileA( filename
);
364 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
368 static void test__llopen( void )
375 filehandle
= _lcreat( filename
, 0 );
376 if (filehandle
== HFILE_ERROR
)
378 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
382 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
383 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
385 filehandle
= _lopen( filename
, OF_READ
);
386 ok( HFILE_ERROR
== _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite shouldn't be able to write!\n" );
387 bytes_read
= _hread( filehandle
, buffer
, strlen( sillytext
) );
388 ok( strlen( sillytext
) == bytes_read
, "file read size error\n" );
389 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
391 filehandle
= _lopen( filename
, OF_READWRITE
);
392 bytes_read
= _hread( filehandle
, buffer
, 2 * strlen( sillytext
) );
393 ok( strlen( sillytext
) == bytes_read
, "file read size error\n" );
394 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite should write just fine\n" );
395 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
397 filehandle
= _lopen( filename
, OF_WRITE
);
398 ok( HFILE_ERROR
== _hread( filehandle
, buffer
, 1 ), "you should only be able to write this file\n" );
399 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite should write just fine\n" );
400 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
402 ret
= DeleteFileA( filename
);
403 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
404 /* TODO - add tests for the SHARE modes - use two processes to pull this one off */
408 static void test__lread( void )
417 filehandle
= _lcreat( filename
, 0 );
418 if (filehandle
== HFILE_ERROR
)
420 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
424 ok( HFILE_ERROR
!= _hwrite( filehandle
, sillytext
, strlen( sillytext
) ), "_hwrite complains\n" );
426 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
428 filehandle
= _lopen( filename
, OF_READ
);
430 ok( HFILE_ERROR
!= filehandle
, "couldn't open file \"%s\" again (err=%ld)\n", filename
, GetLastError());
432 bytes_read
= _lread( filehandle
, buffer
, 2 * strlen( sillytext
) );
434 ok( lstrlenA( sillytext
) == bytes_read
, "file read size error\n" );
436 for (bytes_wanted
= 0; bytes_wanted
< strlen( sillytext
); bytes_wanted
++)
438 ok( 0 == _llseek( filehandle
, 0, FILE_BEGIN
), "_llseek complains\n" );
439 ok( _lread( filehandle
, buffer
, bytes_wanted
) == bytes_wanted
, "erratic _hread return value\n" );
440 for (i
= 0; i
< bytes_wanted
; i
++)
442 ok( buffer
[i
] == sillytext
[i
], "that's not what's written\n" );
446 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
448 ret
= DeleteFileA( filename
);
449 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
453 static void test__lwrite( void )
462 HLOCAL memory_object
;
466 filehandle
= _lcreat( filename
, 0 );
467 if (filehandle
== HFILE_ERROR
)
469 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
473 ok( HFILE_ERROR
!= _lwrite( filehandle
, "", 0 ), "_hwrite complains\n" );
475 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
477 filehandle
= _lopen( filename
, OF_READ
);
479 bytes_read
= _hread( filehandle
, buffer
, 1);
481 ok( 0 == bytes_read
, "file read size error\n" );
483 ok( HFILE_ERROR
!= _lclose(filehandle
), "_lclose complains\n" );
485 filehandle
= _lopen( filename
, OF_READWRITE
);
489 srand( (unsigned)time( NULL
) );
490 for (blocks
= 0; blocks
< 100; blocks
++)
492 for (i
= 0; i
< (long)sizeof( buffer
); i
++)
495 checksum
[0] = checksum
[0] + buffer
[i
];
497 ok( HFILE_ERROR
!= _lwrite( filehandle
, buffer
, sizeof( buffer
) ), "_hwrite complains\n" );
498 bytes_written
= bytes_written
+ sizeof( buffer
);
501 ok( HFILE_ERROR
!= _lwrite( filehandle
, checksum
, 1 ), "_hwrite complains\n" );
504 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
506 memory_object
= LocalAlloc( LPTR
, bytes_written
);
508 ok( 0 != memory_object
, "LocalAlloc fails, could be out of memory\n" );
510 contents
= LocalLock( memory_object
);
512 filehandle
= _lopen( filename
, OF_READ
);
514 contents
= LocalLock( memory_object
);
516 ok( NULL
!= contents
, "LocalLock whines\n" );
518 ok( bytes_written
== _hread( filehandle
, contents
, bytes_written
), "read length differ from write length\n" );
524 checksum
[0] += contents
[i
];
527 while (i
< bytes_written
- 1);
529 ok( checksum
[0] == contents
[i
], "stored checksum differ from computed checksum\n" );
531 ok( HFILE_ERROR
!= _lclose( filehandle
), "_lclose complains\n" );
533 ret
= DeleteFileA( filename
);
534 ok( ret
, "DeleteFile failed (%ld)\n", GetLastError( ) );
537 static void test_CopyFileA(void)
539 char temp_path
[MAX_PATH
];
540 char source
[MAX_PATH
], dest
[MAX_PATH
];
541 static const char prefix
[] = "pfx";
548 ret
= GetTempPathA(MAX_PATH
, temp_path
);
549 ok(ret
!= 0, "GetTempPathA error %ld\n", GetLastError());
550 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
552 ret
= GetTempFileNameA(temp_path
, prefix
, 0, source
);
553 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
555 /* make the source have not zero size */
556 hfile
= CreateFileA(source
, GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
557 ok(hfile
!= INVALID_HANDLE_VALUE
, "failed to open source file\n");
558 retok
= WriteFile(hfile
, prefix
, sizeof(prefix
), &ret
, NULL
);
559 ok( retok
&& ret
== sizeof(prefix
),
560 "WriteFile error %ld\n", GetLastError());
561 ok(GetFileSize(hfile
, NULL
) == sizeof(prefix
), "source file has wrong size\n");
562 /* get the file time and change it to prove the difference */
563 ret
= GetFileTime(hfile
, NULL
, NULL
, &ft1
);
564 ok( ret
, "GetFileTime error %ld\n", GetLastError());
565 ft1
.dwLowDateTime
-= 600000000; /* 60 second */
566 ret
= SetFileTime(hfile
, NULL
, NULL
, &ft1
);
567 ok( ret
, "SetFileTime error %ld\n", GetLastError());
568 GetFileTime(hfile
, NULL
, NULL
, &ft1
); /* get the actual time back */
571 ret
= GetTempFileNameA(temp_path
, prefix
, 0, dest
);
572 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
574 SetLastError(0xdeadbeef);
575 ret
= CopyFileA(source
, dest
, TRUE
);
576 ok(!ret
&& GetLastError() == ERROR_FILE_EXISTS
,
577 "CopyFileA: unexpected error %ld\n", GetLastError());
579 ret
= CopyFileA(source
, dest
, FALSE
);
580 ok(ret
, "CopyFileA: error %ld\n", GetLastError());
582 /* make sure that destination has correct size */
583 hfile
= CreateFileA(dest
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0);
584 ok(hfile
!= INVALID_HANDLE_VALUE
, "failed to open destination file\n");
585 ret
= GetFileSize(hfile
, NULL
);
586 ok(ret
== sizeof(prefix
), "destination file has wrong size %ld\n", ret
);
588 /* make sure that destination has the same filetime */
589 ret
= GetFileTime(hfile
, NULL
, NULL
, &ft2
);
590 ok( ret
, "GetFileTime error %ld\n", GetLastError());
591 ok(CompareFileTime(&ft1
, &ft2
) == 0, "destination file has wrong filetime\n");
593 SetLastError(0xdeadbeef);
594 ret
= CopyFileA(source
, dest
, FALSE
);
595 ok(!ret
&& GetLastError() == ERROR_SHARING_VIOLATION
,
596 "CopyFileA: ret = %ld, unexpected error %ld\n", ret
, GetLastError());
598 /* make sure that destination still has correct size */
599 ret
= GetFileSize(hfile
, NULL
);
600 ok(ret
== sizeof(prefix
), "destination file has wrong size %ld\n", ret
);
601 retok
= ReadFile(hfile
, buf
, sizeof(buf
), &ret
, NULL
);
602 ok( retok
&& ret
== sizeof(prefix
),
603 "ReadFile: error %ld\n", GetLastError());
604 ok(!memcmp(prefix
, buf
, sizeof(prefix
)), "buffer contents mismatch\n");
607 ret
= DeleteFileA(source
);
608 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
609 ret
= DeleteFileA(dest
);
610 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
613 static void test_CopyFileW(void)
615 WCHAR temp_path
[MAX_PATH
];
616 WCHAR source
[MAX_PATH
], dest
[MAX_PATH
];
617 static const WCHAR prefix
[] = {'p','f','x',0};
620 ret
= GetTempPathW(MAX_PATH
, temp_path
);
621 if (ret
==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED
)
623 ok(ret
!= 0, "GetTempPathW error %ld\n", GetLastError());
624 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
626 ret
= GetTempFileNameW(temp_path
, prefix
, 0, source
);
627 ok(ret
!= 0, "GetTempFileNameW error %ld\n", GetLastError());
629 ret
= GetTempFileNameW(temp_path
, prefix
, 0, dest
);
630 ok(ret
!= 0, "GetTempFileNameW error %ld\n", GetLastError());
632 ret
= CopyFileW(source
, dest
, TRUE
);
633 ok(!ret
&& GetLastError() == ERROR_FILE_EXISTS
,
634 "CopyFileW: unexpected error %ld\n", GetLastError());
636 ret
= CopyFileW(source
, dest
, FALSE
);
637 ok(ret
, "CopyFileW: error %ld\n", GetLastError());
639 ret
= DeleteFileW(source
);
640 ok(ret
, "DeleteFileW: error %ld\n", GetLastError());
641 ret
= DeleteFileW(dest
);
642 ok(ret
, "DeleteFileW: error %ld\n", GetLastError());
645 static void test_CreateFileA(void)
648 char temp_path
[MAX_PATH
];
649 char filename
[MAX_PATH
];
650 static const char prefix
[] = "pfx";
653 ret
= GetTempPathA(MAX_PATH
, temp_path
);
654 ok(ret
!= 0, "GetTempPathA error %ld\n", GetLastError());
655 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
657 ret
= GetTempFileNameA(temp_path
, prefix
, 0, filename
);
658 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
660 hFile
= CreateFileA(filename
, GENERIC_READ
, 0, NULL
,
661 CREATE_NEW
, FILE_FLAG_RANDOM_ACCESS
, 0);
662 ok(hFile
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_FILE_EXISTS
,
663 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
665 ret
= DeleteFileA(filename
);
666 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
669 static void test_CreateFileW(void)
672 WCHAR temp_path
[MAX_PATH
];
673 WCHAR filename
[MAX_PATH
];
674 static const WCHAR emptyW
[]={'\0'};
675 static const WCHAR prefix
[] = {'p','f','x',0};
676 static const WCHAR bogus
[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
679 ret
= GetTempPathW(MAX_PATH
, temp_path
);
680 if (ret
==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED
)
682 ok(ret
!= 0, "GetTempPathW error %ld\n", GetLastError());
683 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
685 ret
= GetTempFileNameW(temp_path
, prefix
, 0, filename
);
686 ok(ret
!= 0, "GetTempFileNameW error %ld\n", GetLastError());
688 hFile
= CreateFileW(filename
, GENERIC_READ
, 0, NULL
,
689 CREATE_NEW
, FILE_FLAG_RANDOM_ACCESS
, 0);
690 ok(hFile
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_FILE_EXISTS
,
691 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
693 ret
= DeleteFileW(filename
);
694 ok(ret
, "DeleteFileW: error %ld\n", GetLastError());
696 #if 0 /* this test crashes on NT4.0 */
697 hFile
= CreateFileW(NULL
, GENERIC_READ
, 0, NULL
,
698 CREATE_NEW
, FILE_FLAG_RANDOM_ACCESS
, 0);
699 ok(hFile
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
700 "CreateFileW(NULL) returned ret=%p error=%ld\n",hFile
,GetLastError());
703 hFile
= CreateFileW(emptyW
, GENERIC_READ
, 0, NULL
,
704 CREATE_NEW
, FILE_FLAG_RANDOM_ACCESS
, 0);
705 ok(hFile
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
706 "CreateFileW(\"\") returned ret=%p error=%ld\n",hFile
,GetLastError());
708 /* test the result of opening a nonexistent driver name */
709 hFile
= CreateFileW(bogus
, 0, FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
710 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
711 ok(hFile
== INVALID_HANDLE_VALUE
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
712 "CreateFileW on invalid VxD name returned ret=%p error=%ld\n",hFile
,GetLastError());
715 static void test_GetTempFileNameA(void)
719 char expected
[MAX_PATH
+ 10];
720 char windowsdir
[MAX_PATH
+ 10];
721 char windowsdrive
[3];
723 result
= GetWindowsDirectory(windowsdir
, sizeof(windowsdir
));
724 ok(result
< sizeof(windowsdir
), "windowsdir is abnormally long!\n");
725 ok(result
!= 0, "GetWindowsDirectory: error %ld\n", GetLastError());
727 /* If the Windows directory is the root directory, it ends in backslash, not else. */
728 if (strlen(windowsdir
) != 3) /* As in "C:\" or "F:\" */
730 strcat(windowsdir
, "\\");
733 windowsdrive
[0] = windowsdir
[0];
734 windowsdrive
[1] = windowsdir
[1];
735 windowsdrive
[2] = '\0';
737 result
= GetTempFileNameA(windowsdrive
, "abc", 1, out
);
738 ok(result
!= 0, "GetTempFileNameA: error %ld\n", GetLastError());
739 ok(((out
[0] == windowsdrive
[0]) && (out
[1] == ':')) && (out
[2] == '\\'),
740 "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
741 windowsdrive
[0], out
);
743 result
= GetTempFileNameA(windowsdir
, "abc", 2, out
);
744 ok(result
!= 0, "GetTempFileNameA: error %ld\n", GetLastError());
746 strcat(expected
, windowsdir
);
747 strcat(expected
, "abc2.tmp");
748 ok(lstrcmpiA(out
, expected
) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
752 static void test_DeleteFileA( void )
756 ret
= DeleteFileA(NULL
);
757 ok(!ret
&& (GetLastError() == ERROR_INVALID_PARAMETER
||
758 GetLastError() == ERROR_PATH_NOT_FOUND
),
759 "DeleteFileA(NULL) returned ret=%d error=%ld\n",ret
,GetLastError());
761 ret
= DeleteFileA("");
762 ok(!ret
&& (GetLastError() == ERROR_PATH_NOT_FOUND
||
763 GetLastError() == ERROR_BAD_PATHNAME
),
764 "DeleteFileA(\"\") returned ret=%d error=%ld\n",ret
,GetLastError());
766 ret
= DeleteFileA("nul");
767 ok(!ret
&& (GetLastError() == ERROR_FILE_NOT_FOUND
||
768 GetLastError() == ERROR_INVALID_PARAMETER
||
769 GetLastError() == ERROR_ACCESS_DENIED
||
770 GetLastError() == ERROR_INVALID_FUNCTION
),
771 "DeleteFileA(\"nul\") returned ret=%d error=%ld\n",ret
,GetLastError());
774 static void test_DeleteFileW( void )
777 static const WCHAR emptyW
[]={'\0'};
779 ret
= DeleteFileW(NULL
);
780 if (ret
==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED
)
782 ok(!ret
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
783 "DeleteFileW(NULL) returned ret=%d error=%ld\n",ret
,GetLastError());
785 ret
= DeleteFileW(emptyW
);
786 ok(!ret
&& GetLastError() == ERROR_PATH_NOT_FOUND
,
787 "DeleteFileW(\"\") returned ret=%d error=%ld\n",ret
,GetLastError());
790 #define IsDotDir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
792 static void test_MoveFileA(void)
794 char tempdir
[MAX_PATH
];
795 char source
[MAX_PATH
], dest
[MAX_PATH
];
796 static const char prefix
[] = "pfx";
799 ret
= GetTempPathA(MAX_PATH
, tempdir
);
800 ok(ret
!= 0, "GetTempPathA error %ld\n", GetLastError());
801 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
803 ret
= GetTempFileNameA(tempdir
, prefix
, 0, source
);
804 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
806 ret
= GetTempFileNameA(tempdir
, prefix
, 0, dest
);
807 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
809 ret
= MoveFileA(source
, dest
);
810 ok(!ret
&& GetLastError() == ERROR_ALREADY_EXISTS
,
811 "MoveFileA: unexpected error %ld\n", GetLastError());
813 ret
= DeleteFileA(dest
);
814 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
816 ret
= MoveFileA(source
, dest
);
817 ok(ret
, "MoveFileA: failed, error %ld\n", GetLastError());
819 lstrcatA(tempdir
, "Remove Me");
820 ret
= CreateDirectoryA(tempdir
, NULL
);
821 ok(ret
== TRUE
, "CreateDirectoryA failed\n");
823 lstrcpyA(source
, dest
);
824 lstrcpyA(dest
, tempdir
);
825 lstrcatA(dest
, "\\wild?.*");
826 /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
827 ret
= MoveFileA(source
, dest
);
828 ok(!ret
, "MoveFileA: shouldn't move to wildcard file\n");
829 ok(GetLastError() == ERROR_INVALID_NAME
|| /* NT */
830 GetLastError() == ERROR_FILE_NOT_FOUND
, /* Win9x */
831 "MoveFileA: with wildcards, unexpected error %ld\n", GetLastError());
832 if (ret
|| (GetLastError() != ERROR_INVALID_NAME
))
835 char temppath
[MAX_PATH
];
838 lstrcpyA(temppath
, tempdir
);
839 lstrcatA(temppath
, "\\*.*");
840 hFind
= FindFirstFileA(temppath
, &fd
);
841 if (INVALID_HANDLE_VALUE
!= hFind
)
846 lpName
= fd
.cAlternateFileName
;
848 lpName
= fd
.cFileName
;
849 ok(IsDotDir(lpName
), "MoveFileA: wildcards file created!\n");
851 while (FindNextFileA(hFind
, &fd
));
855 ret
= DeleteFileA(source
);
856 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
857 ret
= DeleteFileA(dest
);
858 ok(!ret
, "DeleteFileA: error %ld\n", GetLastError());
859 ret
= RemoveDirectoryA(tempdir
);
860 ok(ret
, "DeleteDirectoryA: error %ld\n", GetLastError());
863 static void test_MoveFileW(void)
865 WCHAR temp_path
[MAX_PATH
];
866 WCHAR source
[MAX_PATH
], dest
[MAX_PATH
];
867 static const WCHAR prefix
[] = {'p','f','x',0};
870 ret
= GetTempPathW(MAX_PATH
, temp_path
);
871 if (ret
==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED
)
873 ok(ret
!= 0, "GetTempPathW error %ld\n", GetLastError());
874 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
876 ret
= GetTempFileNameW(temp_path
, prefix
, 0, source
);
877 ok(ret
!= 0, "GetTempFileNameW error %ld\n", GetLastError());
879 ret
= GetTempFileNameW(temp_path
, prefix
, 0, dest
);
880 ok(ret
!= 0, "GetTempFileNameW error %ld\n", GetLastError());
882 ret
= MoveFileW(source
, dest
);
883 ok(!ret
&& GetLastError() == ERROR_ALREADY_EXISTS
,
884 "CopyFileW: unexpected error %ld\n", GetLastError());
886 ret
= DeleteFileW(source
);
887 ok(ret
, "DeleteFileW: error %ld\n", GetLastError());
888 ret
= DeleteFileW(dest
);
889 ok(ret
, "DeleteFileW: error %ld\n", GetLastError());
892 #define PATTERN_OFFSET 0x10
894 static void test_offset_in_overlapped_structure(void)
900 BYTE buf
[256], pattern
[] = "TeSt";
902 char temp_path
[MAX_PATH
], temp_fname
[MAX_PATH
];
905 ret
=GetTempPathA(MAX_PATH
, temp_path
);
906 ok( ret
, "GetTempPathA error %ld\n", GetLastError());
907 ret
=GetTempFileNameA(temp_path
, "pfx", 0, temp_fname
);
908 ok( ret
, "GetTempFileNameA error %ld\n", GetLastError());
910 /*** Write File *****************************************************/
912 hFile
= CreateFileA(temp_fname
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
913 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA error %ld\n", GetLastError());
915 for(i
= 0; i
< sizeof(buf
); i
++) buf
[i
] = i
;
916 ret
= WriteFile(hFile
, buf
, sizeof(buf
), &done
, NULL
);
917 ok( ret
, "WriteFile error %ld\n", GetLastError());
918 ok(done
== sizeof(buf
), "expected number of bytes written %lu\n", done
);
920 memset(&ov
, 0, sizeof(ov
));
921 S(U(ov
)).Offset
= PATTERN_OFFSET
;
922 S(U(ov
)).OffsetHigh
= 0;
923 rc
=WriteFile(hFile
, pattern
, sizeof(pattern
), &done
, &ov
);
924 /* Win 9x does not support the overlapped I/O on files */
925 if (rc
|| GetLastError()!=ERROR_INVALID_PARAMETER
) {
926 ok(rc
, "WriteFile error %ld\n", GetLastError());
927 ok(done
== sizeof(pattern
), "expected number of bytes written %lu\n", done
);
928 /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
929 ok(SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
) == (PATTERN_OFFSET
+ sizeof(pattern
)),
930 "expected file offset %d\n", PATTERN_OFFSET
+ sizeof(pattern
));
932 S(U(ov
)).Offset
= sizeof(buf
) * 2;
933 S(U(ov
)).OffsetHigh
= 0;
934 ret
= WriteFile(hFile
, pattern
, sizeof(pattern
), &done
, &ov
);
935 ok( ret
, "WriteFile error %ld\n", GetLastError());
936 ok(done
== sizeof(pattern
), "expected number of bytes written %lu\n", done
);
937 /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
938 ok(SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
) == (sizeof(buf
) * 2 + sizeof(pattern
)),
939 "expected file offset %d\n", sizeof(buf
) * 2 + sizeof(pattern
));
944 /*** Read File *****************************************************/
946 hFile
= CreateFileA(temp_fname
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0);
947 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA error %ld\n", GetLastError());
949 memset(buf
, 0, sizeof(buf
));
950 memset(&ov
, 0, sizeof(ov
));
951 S(U(ov
)).Offset
= PATTERN_OFFSET
;
952 S(U(ov
)).OffsetHigh
= 0;
953 rc
=ReadFile(hFile
, buf
, sizeof(pattern
), &done
, &ov
);
954 /* Win 9x does not support the overlapped I/O on files */
955 if (rc
|| GetLastError()!=ERROR_INVALID_PARAMETER
) {
956 ok(rc
, "ReadFile error %ld\n", GetLastError());
957 ok(done
== sizeof(pattern
), "expected number of bytes read %lu\n", done
);
958 /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
959 ok(SetFilePointer(hFile
, 0, NULL
, FILE_CURRENT
) == (PATTERN_OFFSET
+ sizeof(pattern
)),
960 "expected file offset %d\n", PATTERN_OFFSET
+ sizeof(pattern
));
961 ok(!memcmp(buf
, pattern
, sizeof(pattern
)), "pattern match failed\n");
966 ret
= DeleteFileA(temp_fname
);
967 ok( ret
, "DeleteFileA error %ld\n", GetLastError());
970 static void test_LockFile(void)
974 OVERLAPPED overlapped
;
975 int limited_LockFile
;
976 int limited_UnLockFile
;
977 int lockfileex_capable
;
979 handle
= CreateFileA( filename
, GENERIC_READ
| GENERIC_WRITE
,
980 FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
981 CREATE_ALWAYS
, 0, 0 );
982 if (handle
== INVALID_HANDLE_VALUE
)
984 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
987 ok( WriteFile( handle
, sillytext
, strlen(sillytext
), &written
, NULL
), "write failed\n" );
989 ok( LockFile( handle
, 0, 0, 0, 0 ), "LockFile failed\n" );
990 ok( UnlockFile( handle
, 0, 0, 0, 0 ), "UnlockFile failed\n" );
992 limited_UnLockFile
= 0;
993 if (UnlockFile( handle
, 0, 0, 0, 0 ))
995 limited_UnLockFile
= 1;
998 ok( LockFile( handle
, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
999 /* overlapping locks must fail */
1000 ok( !LockFile( handle
, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
1001 ok( !LockFile( handle
, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
1002 /* non-overlapping locks must succeed */
1003 ok( LockFile( handle
, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
1005 ok( !UnlockFile( handle
, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
1006 ok( UnlockFile( handle
, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
1007 ok( !UnlockFile( handle
, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
1008 ok( UnlockFile( handle
, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
1010 S(U(overlapped
)).Offset
= 100;
1011 S(U(overlapped
)).OffsetHigh
= 0;
1012 overlapped
.hEvent
= 0;
1014 lockfileex_capable
= dll_capable("kernel32", "LockFileEx");
1015 if (lockfileex_capable
)
1017 /* Test for broken LockFileEx a la Windows 95 OSR2. */
1018 if (LockFileEx( handle
, 0, 0, 100, 0, &overlapped
))
1020 /* LockFileEx is probably OK, test it more. */
1021 ok( LockFileEx( handle
, 0, 0, 100, 0, &overlapped
),
1022 "LockFileEx 100,100 failed\n" );
1026 /* overlapping shared locks are OK */
1027 S(U(overlapped
)).Offset
= 150;
1028 limited_UnLockFile
|| ok( LockFileEx( handle
, 0, 0, 100, 0, &overlapped
), "LockFileEx 150,100 failed\n" );
1030 /* but exclusive is not */
1031 if (lockfileex_capable
)
1033 ok( !LockFileEx( handle
, LOCKFILE_EXCLUSIVE_LOCK
|LOCKFILE_FAIL_IMMEDIATELY
,
1034 0, 50, 0, &overlapped
),
1035 "LockFileEx exclusive 150,50 succeeded\n" );
1036 if (dll_capable("kernel32.dll", "UnlockFileEx"))
1038 if (!UnlockFileEx( handle
, 0, 100, 0, &overlapped
))
1039 { /* UnLockFile is capable. */
1040 S(U(overlapped
)).Offset
= 100;
1041 ok( !UnlockFileEx( handle
, 0, 100, 0, &overlapped
),
1042 "UnlockFileEx 150,100 again succeeded\n" );
1047 ok( LockFile( handle
, 0, 0x10000000, 0, 0xf0000000 ), "LockFile failed\n" );
1048 ok( !LockFile( handle
, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
1049 ok( !LockFile( handle
, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
1050 ok( UnlockFile( handle
, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
1052 /* wrap-around lock should not do anything */
1053 /* (but still succeeds on NT4 so we don't check result) */
1054 LockFile( handle
, 0, 0x10000000, 0, 0xf0000001 );
1056 limited_LockFile
= 0;
1057 if (!LockFile( handle
, ~0, ~0, 1, 0 ))
1059 limited_LockFile
= 1;
1062 limited_UnLockFile
|| ok( UnlockFile( handle
, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
1064 /* zero-byte lock */
1065 ok( LockFile( handle
, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
1066 limited_LockFile
|| ok( !LockFile( handle
, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
1067 ok( LockFile( handle
, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
1068 limited_LockFile
|| ok( !LockFile( handle
, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
1070 ok( UnlockFile( handle
, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
1071 !ok( UnlockFile( handle
, 100, 0, 10, 0 ), "UnlockFile 100,10 failed\n" );
1073 ok( UnlockFile( handle
, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
1075 CloseHandle( handle
);
1076 DeleteFileA( filename
);
1079 static inline int is_sharing_compatible( DWORD access1
, DWORD sharing1
, DWORD access2
, DWORD sharing2
)
1081 if (!access1
|| !access2
) return 1;
1082 if ((access1
& GENERIC_READ
) && !(sharing2
& FILE_SHARE_READ
)) return 0;
1083 if ((access1
& GENERIC_WRITE
) && !(sharing2
& FILE_SHARE_WRITE
)) return 0;
1084 if ((access1
& DELETE
) && !(sharing2
& FILE_SHARE_DELETE
)) return 0;
1085 if ((access2
& GENERIC_READ
) && !(sharing1
& FILE_SHARE_READ
)) return 0;
1086 if ((access2
& GENERIC_WRITE
) && !(sharing1
& FILE_SHARE_WRITE
)) return 0;
1087 if ((access2
& DELETE
) && !(sharing1
& FILE_SHARE_DELETE
)) return 0;
1091 static void test_file_sharing(void)
1093 static const DWORD access_modes
[] =
1094 { 0, GENERIC_READ
, GENERIC_WRITE
, GENERIC_READ
|GENERIC_WRITE
,
1095 DELETE
, GENERIC_READ
|DELETE
, GENERIC_WRITE
|DELETE
, GENERIC_READ
|GENERIC_WRITE
|DELETE
};
1096 static const DWORD sharing_modes
[] =
1097 { 0, FILE_SHARE_READ
,
1098 FILE_SHARE_WRITE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
,
1099 FILE_SHARE_DELETE
, FILE_SHARE_READ
|FILE_SHARE_DELETE
,
1100 FILE_SHARE_WRITE
|FILE_SHARE_DELETE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
};
1105 /* make sure the file exists */
1106 h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
1107 if (h
== INVALID_HANDLE_VALUE
)
1109 ok(0, "couldn't create file \"%s\" (err=%ld)\n", filename
, GetLastError());
1114 for (a1
= 0; a1
< sizeof(access_modes
)/sizeof(access_modes
[0]); a1
++)
1116 for (s1
= 0; s1
< sizeof(sharing_modes
)/sizeof(sharing_modes
[0]); s1
++)
1118 h
= CreateFileA( filename
, access_modes
[a1
], sharing_modes
[s1
],
1119 NULL
, OPEN_EXISTING
, 0, 0 );
1120 if (h
== INVALID_HANDLE_VALUE
)
1122 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename
,GetLastError());
1125 for (a2
= 0; a2
< sizeof(access_modes
)/sizeof(access_modes
[0]); a2
++)
1127 for (s2
= 0; s2
< sizeof(sharing_modes
)/sizeof(sharing_modes
[0]); s2
++)
1129 SetLastError(0xdeadbeef);
1130 h2
= CreateFileA( filename
, access_modes
[a2
], sharing_modes
[s2
],
1131 NULL
, OPEN_EXISTING
, 0, 0 );
1132 if (is_sharing_compatible( access_modes
[a1
], sharing_modes
[s1
],
1133 access_modes
[a2
], sharing_modes
[s2
] ))
1135 ret
= GetLastError();
1136 ok( ERROR_SHARING_VIOLATION
== ret
|| 0 == ret
,
1137 "Windows 95 sets GetLastError() = ERROR_SHARING_VIOLATION and\n"
1138 " Windows XP GetLastError() = 0, but now it is %d.\n"
1139 " indexes = %d, %d, %d, %d\n"
1140 " modes =\n %lx/%lx/%lx/%lx\n",
1143 access_modes
[a1
], sharing_modes
[s1
],
1144 access_modes
[a2
], sharing_modes
[s2
]
1149 ok( h2
== INVALID_HANDLE_VALUE
,
1150 "open succeeded for modes %lx/%lx/%lx/%lx\n",
1151 access_modes
[a1
], sharing_modes
[s1
],
1152 access_modes
[a2
], sharing_modes
[s2
] );
1153 if (h2
== INVALID_HANDLE_VALUE
)
1154 ok( GetLastError() == ERROR_SHARING_VIOLATION
,
1155 "wrong error code %ld\n", GetLastError() );
1157 if (h2
!= INVALID_HANDLE_VALUE
) CloseHandle( h2
);
1164 SetLastError(0xdeadbeef);
1165 h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0, 0 );
1166 ok( h
!= INVALID_HANDLE_VALUE
, "CreateFileA error %ld\n", GetLastError() );
1168 SetLastError(0xdeadbeef);
1169 h2
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0 );
1170 ok( h2
== INVALID_HANDLE_VALUE
, "CreateFileA should fail\n");
1171 ok( GetLastError() == ERROR_SHARING_VIOLATION
, "wrong error code %ld\n", GetLastError() );
1173 h2
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
, 0, 0 );
1174 ok( h2
!= INVALID_HANDLE_VALUE
, "CreateFileA error %ld\n", GetLastError() );
1179 DeleteFileA( filename
);
1182 static char get_windows_drive(void)
1184 char windowsdir
[MAX_PATH
];
1185 GetWindowsDirectory(windowsdir
, sizeof(windowsdir
));
1186 return windowsdir
[0];
1189 static void test_FindFirstFileA(void)
1192 WIN32_FIND_DATAA search_results
;
1194 char buffer
[5] = "C:\\";
1196 /* try FindFirstFileA on "C:\" */
1197 buffer
[0] = get_windows_drive();
1198 handle
= FindFirstFileA(buffer
,&search_results
);
1199 err
= GetLastError();
1200 ok ( handle
== INVALID_HANDLE_VALUE
, "FindFirstFile on root directory should Fail\n");
1201 if (handle
== INVALID_HANDLE_VALUE
)
1202 ok ( err
== ERROR_FILE_NOT_FOUND
, "Bad Error number %d\n", err
);
1204 /* try FindFirstFileA on "C:\*" */
1205 strcat(buffer
, "*");
1206 handle
= FindFirstFileA(buffer
,&search_results
);
1207 ok ( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on %s should succeed\n", buffer
);
1208 ok ( FindClose(handle
) == TRUE
, "Failed to close handle\n");
1211 static void test_FindNextFileA(void)
1214 WIN32_FIND_DATAA search_results
;
1216 char buffer
[5] = "C:\\*";
1218 buffer
[0] = get_windows_drive();
1219 handle
= FindFirstFileA(buffer
,&search_results
);
1220 ok ( handle
!= INVALID_HANDLE_VALUE
, "FindFirstFile on C:\\* should succeed\n" );
1221 while (FindNextFile(handle
, &search_results
))
1223 /* get to the end of the files */
1225 ok ( FindClose(handle
) == TRUE
, "Failed to close handle\n");
1226 err
= GetLastError();
1227 ok ( err
== ERROR_NO_MORE_FILES
, "GetLastError should return ERROR_NO_MORE_FILES\n");
1230 static int test_Mapfile_createtemp(HANDLE
*handle
)
1232 SetFileAttributesA(filename
,FILE_ATTRIBUTE_NORMAL
);
1233 DeleteFile(filename
);
1234 *handle
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, 0,
1235 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1236 if (*handle
!= INVALID_HANDLE_VALUE
) {
1244 static void test_MapFile(void)
1249 ok(test_Mapfile_createtemp(&handle
), "Couldn't create test file.\n");
1251 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0x1000, "named_file_map" );
1252 ok( hmap
!= NULL
, "mapping should work, I named it!\n" );
1254 ok( CloseHandle( hmap
), "can't close mapping handle\n");
1256 /* We have to close file before we try new stuff with mapping again.
1257 Else we would always succeed on XP or block descriptors on 95. */
1258 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0, NULL
);
1259 ok( hmap
!= NULL
, "We should still be able to map!\n" );
1260 ok( CloseHandle( hmap
), "can't close mapping handle\n");
1261 ok( CloseHandle( handle
), "can't close file handle\n");
1264 ok(test_Mapfile_createtemp(&handle
), "Couldn't create test file.\n");
1266 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0, 0, NULL
);
1267 ok( hmap
== NULL
, "mapped zero size file\n");
1268 ok( GetLastError() == ERROR_FILE_INVALID
, "not ERROR_FILE_INVALID\n");
1270 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0x1000, 0, NULL
);
1271 ok( hmap
== NULL
, "mapping should fail\n");
1272 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1274 hmap
= CreateFileMapping( handle
, NULL
, PAGE_READWRITE
, 0x1000, 0x10000, NULL
);
1275 ok( hmap
== NULL
, "mapping should fail\n");
1276 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1278 /* On XP you can now map again, on Win 95 you cannot. */
1280 ok( CloseHandle( handle
), "can't close file handle\n");
1281 ok( DeleteFileA( filename
), "DeleteFile failed after map\n" );
1284 static void test_GetFileType(void)
1287 HANDLE h
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
1288 ok( h
!= INVALID_HANDLE_VALUE
, "open %s failed\n", filename
);
1289 type
= GetFileType(h
);
1290 ok( type
== FILE_TYPE_DISK
, "expected type disk got %ld\n", type
);
1292 h
= CreateFileA( "nul", GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, OPEN_EXISTING
, 0, 0 );
1293 ok( h
!= INVALID_HANDLE_VALUE
, "open nul failed\n" );
1294 type
= GetFileType(h
);
1295 ok( type
== FILE_TYPE_CHAR
, "expected type char for nul got %ld\n", type
);
1297 DeleteFileA( filename
);
1300 static int completion_count
;
1302 static void CALLBACK
FileIOComplete(DWORD dwError
, DWORD dwBytes
, LPOVERLAPPED ovl
)
1304 /* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
1305 ReleaseSemaphore(ovl
->hEvent
, 1, NULL
);
1309 static void test_async_file_errors(void)
1311 char szFile
[MAX_PATH
];
1312 HANDLE hSem
= CreateSemaphoreW(NULL
, 1, 1, NULL
);
1314 LPVOID lpBuffer
= HeapAlloc(GetProcessHeap(), 0, 4096);
1316 S(U(ovl
)).Offset
= 0;
1317 S(U(ovl
)).OffsetHigh
= 0;
1319 completion_count
= 0;
1321 GetWindowsDirectoryA(szFile
, sizeof(szFile
)/sizeof(szFile
[0])-1-strlen("\\win.ini"));
1322 strcat(szFile
, "\\win.ini");
1323 hFile
= CreateFileA(szFile
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
, NULL
, OPEN_ALWAYS
, FILE_FLAG_OVERLAPPED
, NULL
);
1324 ok(hFile
!= NULL
, "CreateFileA(%s ...) failed\n", szFile
);
1328 while (WaitForSingleObjectEx(hSem
, INFINITE
, TRUE
) == WAIT_IO_COMPLETION
)
1330 res
= ReadFileEx(hFile
, lpBuffer
, 4096, &ovl
, FileIOComplete
);
1331 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
1334 S(U(ovl
)).Offset
+= 4096;
1335 /* i/o completion routine only called if ReadFileEx returned success.
1336 * we only care about violations of this rule so undo what should have
1340 ok(completion_count
== 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count
);
1341 /*printf("Error = %ld\n", GetLastError());*/
1344 static void test_read_write(void)
1348 char temp_path
[MAX_PATH
];
1349 char filename
[MAX_PATH
];
1350 static const char prefix
[] = "pfx";
1352 ret
= GetTempPathA(MAX_PATH
, temp_path
);
1353 ok(ret
!= 0, "GetTempPathA error %ld\n", GetLastError());
1354 ok(ret
< MAX_PATH
, "temp path should fit into MAX_PATH\n");
1356 ret
= GetTempFileNameA(temp_path
, prefix
, 0, filename
);
1357 ok(ret
!= 0, "GetTempFileNameA error %ld\n", GetLastError());
1359 hFile
= CreateFileA(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1360 CREATE_ALWAYS
, FILE_FLAG_RANDOM_ACCESS
, 0);
1361 ok(hFile
!= INVALID_HANDLE_VALUE
, "CreateFileA: error %ld\n", GetLastError());
1363 SetLastError(12345678);
1365 ret
= WriteFile(hFile
, NULL
, 0, &bytes
, NULL
);
1366 ok(ret
&& GetLastError() == 12345678,
1367 "ret = %ld, error %ld\n", ret
, GetLastError());
1368 ok(!bytes
, "bytes = %ld\n", bytes
);
1370 SetLastError(12345678);
1372 ret
= WriteFile(hFile
, NULL
, 10, &bytes
, NULL
);
1373 ok((!ret
&& GetLastError() == ERROR_INVALID_USER_BUFFER
) || /* Win2k */
1374 (ret
&& GetLastError() == 12345678), /* Win9x */
1375 "ret = %ld, error %ld\n", ret
, GetLastError());
1376 ok(!bytes
|| /* Win2k */
1377 bytes
== 10, /* Win9x */
1378 "bytes = %ld\n", bytes
);
1380 /* make sure the file contains data */
1381 WriteFile(hFile
, "this is the test data", 21, &bytes
, NULL
);
1382 SetFilePointer(hFile
, 0, NULL
, FILE_BEGIN
);
1384 SetLastError(12345678);
1386 ret
= ReadFile(hFile
, NULL
, 0, &bytes
, NULL
);
1387 ok(ret
&& GetLastError() == 12345678,
1388 "ret = %ld, error %ld\n", ret
, GetLastError());
1389 ok(!bytes
, "bytes = %ld\n", bytes
);
1391 SetLastError(12345678);
1393 ret
= ReadFile(hFile
, NULL
, 10, &bytes
, NULL
);
1394 ok(!ret
&& (GetLastError() == ERROR_NOACCESS
|| /* Win2k */
1395 GetLastError() == ERROR_INVALID_PARAMETER
), /* Win9x */
1396 "ret = %ld, error %ld\n", ret
, GetLastError());
1397 ok(!bytes
, "bytes = %ld\n", bytes
);
1399 ret
= CloseHandle(hFile
);
1400 ok( ret
, "CloseHandle: error %ld\n", GetLastError());
1401 ret
= DeleteFileA(filename
);
1402 ok( ret
, "DeleteFileA: error %ld\n", GetLastError());
1405 static void test_OpenFile_exists(void)
1410 static const char *file
= "\\winver.exe";
1411 char buff
[MAX_PATH
];
1414 length
= GetSystemDirectoryA(buff
, MAX_PATH
);
1416 if ((length
+ lstrlen(file
) < MAX_PATH
))
1418 lstrcat(buff
, file
);
1420 hFile
= OpenFile(buff
, &ofs
, OF_EXIST
);
1421 ok( hFile
== TRUE
, "%s not found : %ld\n", buff
, GetLastError());
1424 hFile
= OpenFile(".\\foo-bar-foo.baz", &ofs
, OF_EXIST
);
1425 ok( hFile
== HFILE_ERROR
, "hFile != HFILE_ERROR : %ld\n", GetLastError());
1428 static void test_overlapped(void)
1433 /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
1435 memset( &ov
, 0, sizeof ov
);
1437 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1438 ok( r
== TRUE
, "should return false\n");
1439 ok( result
== 0, "result wrong\n");
1443 ov
.InternalHigh
= 0xabcd;
1444 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1445 ok( r
== TRUE
, "should return false\n");
1446 ok( result
== 0xabcd, "result wrong\n");
1448 SetLastError( 0xb00 );
1450 ov
.Internal
= STATUS_INVALID_HANDLE
;
1451 ov
.InternalHigh
= 0xabcd;
1452 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1453 ok (GetLastError() == ERROR_INVALID_HANDLE
, "error wrong\n");
1454 ok( r
== FALSE
, "should return false\n");
1455 ok( result
== 0xabcd, "result wrong\n");
1458 ov
.Internal
= STATUS_PENDING
;
1459 ov
.InternalHigh
= 0xabcd;
1460 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1462 ok (GetLastError() == ERROR_IO_INCOMPLETE
, "error wrong\n");
1464 ok( r
== FALSE
, "should return false\n");
1465 ok( result
== 0, "result wrong\n");
1467 ov
.hEvent
= CreateEvent( NULL
, 1, 1, NULL
);
1468 ov
.Internal
= STATUS_PENDING
;
1469 ov
.InternalHigh
= 0xabcd;
1470 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1471 ok (GetLastError() == ERROR_IO_INCOMPLETE
, "error wrong\n");
1472 ok( r
== FALSE
, "should return false\n");
1474 ResetEvent( ov
.hEvent
);
1476 ov
.Internal
= STATUS_PENDING
;
1477 ov
.InternalHigh
= 0;
1478 r
= GetOverlappedResult(0, &ov
, &result
, 0);
1479 ok (GetLastError() == ERROR_IO_INCOMPLETE
, "error wrong\n");
1480 ok( r
== FALSE
, "should return false\n");
1482 r
= CloseHandle( ov
.hEvent
);
1483 ok( r
== TRUE
, "close handle failed\n");
1496 test_GetTempFileNameA();
1505 test_FindFirstFileA();
1506 test_FindNextFileA();
1508 test_file_sharing();
1509 test_offset_in_overlapped_structure();
1512 test_async_file_errors();
1514 test_OpenFile_exists();