ReactOS 0.4.15-dev-8145-ga541a46
file.c
Go to the documentation of this file.
1/*
2 * Unit tests for file functions in Wine
3 *
4 * Copyright (c) 2002, 2004 Jakob Eriksson
5 * Copyright (c) 2008 Jeff Zaroyko
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 */
22
23#include "precomp.h"
24
25#include <time.h>
26#include <fileapi.h>
27
28#undef DeleteFile /* needed for FILE_DISPOSITION_INFO */
29
31static BOOL (WINAPI *pReplaceFileA)(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
32static BOOL (WINAPI *pReplaceFileW)(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
33static UINT (WINAPI *pGetSystemWindowsDirectoryA)(LPSTR, UINT);
34static BOOL (WINAPI *pGetVolumeNameForVolumeMountPointA)(LPCSTR, LPSTR, DWORD);
35static DWORD (WINAPI *pQueueUserAPC)(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
36static BOOL (WINAPI *pGetFileInformationByHandleEx)(HANDLE, FILE_INFO_BY_HANDLE_CLASS, LPVOID, DWORD);
38static BOOL (WINAPI *pSetFileValidData)(HANDLE, LONGLONG);
39static HRESULT (WINAPI *pCopyFile2)(PCWSTR,PCWSTR,COPYFILE2_EXTENDED_PARAMETERS*);
41static DWORD (WINAPI *pGetFinalPathNameByHandleA)(HANDLE, LPSTR, DWORD, DWORD);
42static DWORD (WINAPI *pGetFinalPathNameByHandleW)(HANDLE, LPWSTR, DWORD, DWORD);
45static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)(LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR*);
46static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN);
47static BOOL (WINAPI *pSetFileInformationByHandle)(HANDLE, FILE_INFO_BY_HANDLE_CLASS, void*, DWORD);
48static void (WINAPI *pRtlInitAnsiString)(PANSI_STRING,PCSZ);
49static void (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
50
51static char filename[MAX_PATH];
52static const char sillytext[] =
53"en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
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"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
57"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
58"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
59"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
60"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
61"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
62"sdlkfjasdlkfj a dslkj adsklf \n \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
63
64struct test_list {
65 const char *file; /* file string to test */
66 const DWORD err; /* Win NT and further error code */
67 const LONG err2; /* Win 9x & ME error code or -1 */
68 const DWORD options; /* option flag to use for open */
69 const BOOL todo_flag; /* todo_wine indicator */
70} ;
71
72static void InitFunctionPointers(void)
73{
76
77 pNtCreateFile = (void *)GetProcAddress(hntdll, "NtCreateFile");
78 pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
79 pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
80 pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
81 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
82
83 pFindFirstFileExA=(void*)GetProcAddress(hkernel32, "FindFirstFileExA");
84 pReplaceFileA=(void*)GetProcAddress(hkernel32, "ReplaceFileA");
85 pReplaceFileW=(void*)GetProcAddress(hkernel32, "ReplaceFileW");
86 pGetSystemWindowsDirectoryA=(void*)GetProcAddress(hkernel32, "GetSystemWindowsDirectoryA");
87 pGetVolumeNameForVolumeMountPointA = (void *) GetProcAddress(hkernel32, "GetVolumeNameForVolumeMountPointA");
88 pQueueUserAPC = (void *) GetProcAddress(hkernel32, "QueueUserAPC");
89 pGetFileInformationByHandleEx = (void *) GetProcAddress(hkernel32, "GetFileInformationByHandleEx");
90 pOpenFileById = (void *) GetProcAddress(hkernel32, "OpenFileById");
91 pSetFileValidData = (void *) GetProcAddress(hkernel32, "SetFileValidData");
92 pCopyFile2 = (void *) GetProcAddress(hkernel32, "CopyFile2");
93 pCreateFile2 = (void *) GetProcAddress(hkernel32, "CreateFile2");
94 pGetFinalPathNameByHandleA = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleA");
95 pGetFinalPathNameByHandleW = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleW");
96 pSetFileInformationByHandle = (void *) GetProcAddress(hkernel32, "SetFileInformationByHandle");
97}
98
99static void test__hread( void )
100{
101 HFILE filehandle;
102 char buffer[10000];
103 LONG bytes_read;
104 LONG bytes_wanted;
105 LONG i;
106 BOOL ret;
107
108 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
110 filehandle = _lcreat( filename, 0 );
111 if (filehandle == HFILE_ERROR)
112 {
113 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
114 return;
115 }
116
117 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
118
119 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
120
121 filehandle = _lopen( filename, OF_READ );
122
123 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError( ) );
124
125 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
126
127 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
128
129 for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
130 {
131 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
132 ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
133 for (i = 0; i < bytes_wanted; i++)
134 {
135 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
136 }
137 }
138
139 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
140
142 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
143}
144
145
146static void test__hwrite( void )
147{
148 HFILE filehandle;
149 char buffer[10000];
150 LONG bytes_read;
151 LONG bytes_written;
153 LONG i;
154 char *contents;
155 HLOCAL memory_object;
156 char checksum[1];
157 BOOL ret;
158
159 filehandle = _lcreat( filename, 0 );
160 if (filehandle == HFILE_ERROR)
161 {
162 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
163 return;
164 }
165
166 ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
167
168 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
169
170 filehandle = _lopen( filename, OF_READ );
171
172 bytes_read = _hread( filehandle, buffer, 1);
173
174 ok( 0 == bytes_read, "file read size error\n" );
175
176 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
177
178 filehandle = _lopen( filename, OF_READWRITE );
179
180 bytes_written = 0;
181 checksum[0] = '\0';
182 srand( (unsigned)time( NULL ) );
183 for (blocks = 0; blocks < 100; blocks++)
184 {
185 for (i = 0; i < (LONG)sizeof( buffer ); i++)
186 {
187 buffer[i] = rand( );
188 checksum[0] = checksum[0] + buffer[i];
189 }
190 ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
191 bytes_written = bytes_written + sizeof( buffer );
192 }
193
194 ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
195 bytes_written++;
196
197 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
198
199 memory_object = LocalAlloc( LPTR, bytes_written );
200
201 ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
202
203 contents = LocalLock( memory_object );
204 ok( NULL != contents, "LocalLock whines\n" );
205
206 filehandle = _lopen( filename, OF_READ );
207
208 contents = LocalLock( memory_object );
209 ok( NULL != contents, "LocalLock whines\n" );
210
211 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
212
213 checksum[0] = '\0';
214 i = 0;
215 do
216 {
217 checksum[0] = checksum[0] + contents[i];
218 i++;
219 }
220 while (i < bytes_written - 1);
221
222 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
223
224 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
225
227 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
228
230}
231
232
233static void test__lclose( void )
234{
235 HFILE filehandle;
236 BOOL ret;
237
238 filehandle = _lcreat( filename, 0 );
239 if (filehandle == HFILE_ERROR)
240 {
241 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
242 return;
243 }
244
245 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
246
247 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
248
250 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
251}
252
253/* helper function for test__lcreat */
254static void get_nt_pathW( const char *name, UNICODE_STRING *nameW )
255{
259 BOOLEAN ret;
260
261 pRtlInitAnsiString( &str, name );
262
263 status = pRtlAnsiStringToUnicodeString( &strW, &str, TRUE );
264 ok( !status, "RtlAnsiStringToUnicodeString failed with %08x\n", status );
265
266 ret = pRtlDosPathNameToNtPathName_U( strW.Buffer, nameW, NULL, NULL );
267 ok( ret, "RtlDosPathNameToNtPathName_U failed\n" );
268
269 pRtlFreeUnicodeString( &strW );
270}
271
272static void test__lcreat( void )
273{
277 HFILE filehandle;
278 char buffer[10000];
279 WIN32_FIND_DATAA search_results;
280 char slashname[] = "testfi/";
281 int err;
284 BOOL ret;
285
286 filehandle = _lcreat( filename, 0 );
287 if (filehandle == HFILE_ERROR)
288 {
289 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
290 return;
291 }
292
293 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
294
295 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
296
297 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
298
299 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
300
301 find = FindFirstFileA( filename, &search_results );
302 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
303 FindClose( find );
304
306 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError());
307
308 filehandle = _lcreat( filename, 1 ); /* readonly */
309 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
310
311 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
312
313 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
314
315 find = FindFirstFileA( filename, &search_results );
316 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
317 FindClose( find );
318
319 SetLastError( 0xdeadbeef );
320 ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
321 ok( GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError() );
322
323 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
324
325 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
326
327 filehandle = _lcreat( filename, 1 ); /* readonly */
328 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError() );
329 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen(sillytext) ),
330 "_hwrite shouldn't be able to write never the less\n" );
331 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
332
333 find = FindFirstFileA( filename, &search_results );
334 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
335 FindClose( find );
336
338 attr.Length = sizeof(attr);
339 attr.RootDirectory = 0;
340 attr.Attributes = OBJ_CASE_INSENSITIVE;
341 attr.ObjectName = &filenameW;
342 attr.SecurityDescriptor = NULL;
343 attr.SecurityQualityOfService = NULL;
344
345 status = pNtCreateFile( &file, GENERIC_READ | GENERIC_WRITE | DELETE, &attr, &io, NULL, 0,
348 ok( status == STATUS_ACCESS_DENIED, "expected STATUS_ACCESS_DENIED, got %08x\n", status );
349 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
350
351 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
354 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
355
356 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
359 ok( status == STATUS_NOT_A_DIRECTORY, "expected STATUS_NOT_A_DIRECTORY, got %08x\n", status );
360
361 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
365 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
366 if (!status) CloseHandle( file );
367
368 pRtlFreeUnicodeString( &filenameW );
369
371 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
373 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
375 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file\n" );
376
377 filehandle = _lcreat( filename, 2 );
378 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
379
380 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
381
382 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
383
384 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
385
386 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
387
388 find = FindFirstFileA( filename, &search_results );
389 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
390 FindClose( find );
391
393 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
394
395 filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
396 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
397
398 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
399
400 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
401
402 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
403
404 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
405
406 find = FindFirstFileA( filename, &search_results );
407 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
408 FindClose( find );
409
411 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
412
413 filehandle=_lcreat (slashname, 0); /* illegal name */
414 if (HFILE_ERROR==filehandle) {
415 err=GetLastError ();
417 "creating file \"%s\" failed with error %d\n", slashname, err);
418 } else { /* only NT succeeds */
419 _lclose(filehandle);
420 find=FindFirstFileA (slashname, &search_results);
422 {
423 ret = FindClose (find);
424 ok (0 != ret, "FindClose complains (%d)\n", GetLastError ());
425 slashname[strlen(slashname)-1]=0;
426 ok (!strcmp (slashname, search_results.cFileName),
427 "found unexpected name \"%s\"\n", search_results.cFileName);
428 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
429 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
430 search_results.dwFileAttributes);
431 }
432 ret = DeleteFileA( slashname );
433 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
434 }
435
436 filehandle=_lcreat (filename, 8); /* illegal attribute */
437 if (HFILE_ERROR==filehandle)
438 ok (0, "couldn't create volume label \"%s\"\n", filename);
439 else {
440 _lclose(filehandle);
441 find=FindFirstFileA (filename, &search_results);
443 ok (0, "file \"%s\" not found\n", filename);
444 else {
445 const char *name = strrchr(filename, '\\');
446
447 if (name) name++;
448 else name = filename;
449
450 ret = FindClose(find);
451 ok ( 0 != ret, "FindClose complains (%d)\n", GetLastError ());
452 ok (!strcmp (name, search_results.cFileName),
453 "expected \"%s\", got \"%s\"\n", name, search_results.cFileName);
454 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
455 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_COMPRESSED;
456 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
457 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
458 search_results.dwFileAttributes);
459 }
461 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
462 }
463}
464
465
466static void test__llseek( void )
467{
468 INT i;
469 HFILE filehandle;
470 char buffer[1];
471 LONG bytes_read;
472 BOOL ret;
473
474 filehandle = _lcreat( filename, 0 );
475 if (filehandle == HFILE_ERROR)
476 {
477 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
478 return;
479 }
480
481 for (i = 0; i < 400; i++)
482 {
483 ok( _hwrite( filehandle, sillytext, strlen( sillytext ) ) != -1, "_hwrite complains\n" );
484 }
485 ok( _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ) != -1, "should be able to seek\n" );
486 ok( _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ) != -1, "should be able to seek\n" );
487
488 bytes_read = _hread( filehandle, buffer, 1);
489 ok( 1 == bytes_read, "file read size error\n" );
490 ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
491 ok( _llseek( filehandle, -400 * (LONG)strlen( sillytext ), FILE_END ) != -1, "should be able to seek\n" );
492
493 bytes_read = _hread( filehandle, buffer, 1);
494 ok( 1 == bytes_read, "file read size error\n" );
495 ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
496 ok( _llseek( filehandle, 1000000, FILE_END ) != -1, "should be able to seek past file; poor, poor Windows programmers\n" );
497 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
498
500 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
501}
502
503
504static void test__llopen( void )
505{
506 HFILE filehandle;
507 UINT bytes_read;
508 char buffer[10000];
509 BOOL ret;
510
511 filehandle = _lcreat( filename, 0 );
512 if (filehandle == HFILE_ERROR)
513 {
514 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
515 return;
516 }
517
518 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
519 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
520
521 filehandle = _lopen( filename, OF_READ );
522 ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
523 bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
524 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
525 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
526
527 filehandle = _lopen( filename, OF_READWRITE );
528 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
529 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
530 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
531 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
532
533 filehandle = _lopen( filename, OF_WRITE );
534 ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
535 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
536 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
537
539 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
540 /* TODO - add tests for the SHARE modes - use two processes to pull this one off */
541}
542
543
544static void test__lread( void )
545{
546 HFILE filehandle;
547 char buffer[10000];
548 UINT bytes_read;
549 UINT bytes_wanted;
550 UINT i;
551 BOOL ret;
552
553 filehandle = _lcreat( filename, 0 );
554 if (filehandle == HFILE_ERROR)
555 {
556 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
557 return;
558 }
559
560 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
561
562 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
563
564 filehandle = _lopen( filename, OF_READ );
565
566 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError());
567
568 bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
569
570 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
571
572 for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
573 {
574 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
575 ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
576 for (i = 0; i < bytes_wanted; i++)
577 {
578 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
579 }
580 }
581
582 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
583
585 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
586}
587
588
589static void test__lwrite( void )
590{
591 HFILE filehandle;
592 char buffer[10000];
593 UINT bytes_read;
594 UINT bytes_written;
595 UINT blocks;
596 INT i;
597 char *contents;
598 HLOCAL memory_object;
599 char checksum[1];
600 BOOL ret;
601
602 filehandle = _lcreat( filename, 0 );
603 if (filehandle == HFILE_ERROR)
604 {
605 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
606 return;
607 }
608
609 ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
610
611 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
612
613 filehandle = _lopen( filename, OF_READ );
614
615 bytes_read = _hread( filehandle, buffer, 1);
616
617 ok( 0 == bytes_read, "file read size error\n" );
618
619 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
620
621 filehandle = _lopen( filename, OF_READWRITE );
622
623 bytes_written = 0;
624 checksum[0] = '\0';
625 srand( (unsigned)time( NULL ) );
626 for (blocks = 0; blocks < 100; blocks++)
627 {
628 for (i = 0; i < (INT)sizeof( buffer ); i++)
629 {
630 buffer[i] = rand( );
631 checksum[0] = checksum[0] + buffer[i];
632 }
633 ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
634 bytes_written = bytes_written + sizeof( buffer );
635 }
636
637 ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
638 bytes_written++;
639
640 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
641
642 memory_object = LocalAlloc( LPTR, bytes_written );
643
644 ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
645
646 contents = LocalLock( memory_object );
647 ok( NULL != contents, "LocalLock whines\n" );
648
649 filehandle = _lopen( filename, OF_READ );
650
651 contents = LocalLock( memory_object );
652 ok( NULL != contents, "LocalLock whines\n" );
653
654 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
655
656 checksum[0] = '\0';
657 i = 0;
658 do
659 {
660 checksum[0] += contents[i];
661 i++;
662 }
663 while (i < bytes_written - 1);
664
665 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
666
667 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
668
670 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
671
673}
674
675static void test_CopyFileA(void)
676{
677 char temp_path[MAX_PATH];
679 static const char prefix[] = "pfx";
680 HANDLE hfile;
681 HANDLE hmapfile;
682 FILETIME ft1, ft2;
683 char buf[10];
684 DWORD ret;
685 BOOL retok;
686
688 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
689 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
690
691 ret = GetTempFileNameA(temp_path, prefix, 0, source);
692 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
693
694 /* copying a file to itself must fail */
695 retok = CopyFileA(source, source, FALSE);
696 ok( !retok && (GetLastError() == ERROR_SHARING_VIOLATION || broken(GetLastError() == ERROR_FILE_EXISTS) /* Win 9x */),
697 "copying a file to itself didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
698
699 /* make the source have not zero size */
700 hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
701 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
702 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
703 ok( retok && ret == sizeof(prefix),
704 "WriteFile error %d\n", GetLastError());
705 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
706 /* get the file time and change it to prove the difference */
707 ret = GetFileTime(hfile, NULL, NULL, &ft1);
708 ok( ret, "GetFileTime error %d\n", GetLastError());
709 ft1.dwLowDateTime -= 600000000; /* 60 second */
710 ret = SetFileTime(hfile, NULL, NULL, &ft1);
711 ok( ret, "SetFileTime error %d\n", GetLastError());
712 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
713 CloseHandle(hfile);
714
715 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
716 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
717
718 SetLastError(0xdeadbeef);
721 "CopyFileA: unexpected error %d\n", GetLastError());
722
724 ok(ret, "CopyFileA: error %d\n", GetLastError());
725
726 /* copying from a read-locked source fails */
728 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
729 retok = CopyFileA(source, dest, FALSE);
731 "copying from a read-locked file succeeded when it shouldn't have\n");
732 /* in addition, the source is opened before the destination */
733 retok = CopyFileA("25f99d3b-4ba4-4f66-88f5-2906886993cc", dest, FALSE);
734 ok(!retok && GetLastError() == ERROR_FILE_NOT_FOUND,
735 "copying from a file that doesn't exist failed in an unexpected way (ret=%d, err=%d)\n", retok, GetLastError());
736 CloseHandle(hfile);
737
738 /* copying from a r+w opened, r shared source succeeds */
740 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
741 retok = CopyFileA(source, dest, FALSE);
742 ok(retok,
743 "copying from an r+w opened and r shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
744 CloseHandle(hfile);
745
746 /* copying from a delete-locked source mostly succeeds */
748 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
749 retok = CopyFileA(source, dest, FALSE);
750 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* NT, 2000, XP */,
751 "copying from a delete-locked file failed (ret=%d, err=%d)\n", retok, GetLastError());
752 CloseHandle(hfile);
753
754 /* copying to a write-locked destination fails */
756 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
757 retok = CopyFileA(source, dest, FALSE);
759 "copying to a write-locked file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
760 CloseHandle(hfile);
761
762 /* copying to a r+w opened, w shared destination mostly succeeds */
764 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
765 retok = CopyFileA(source, dest, FALSE);
766 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
767 "copying to a r+w opened and w shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
768 CloseHandle(hfile);
769
770 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
773 "failed to open destination file, error %d\n", GetLastError());
774 if (hfile != INVALID_HANDLE_VALUE)
775 {
776 retok = CopyFileA(source, dest, FALSE);
778 "copying to a delete-locked shared file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
779 CloseHandle(hfile);
780 }
781
782 /* copy to a file that's opened the way Wine opens the source */
784 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
785 retok = CopyFileA(source, dest, FALSE);
786 ok(retok || broken(GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
787 "copying to a file opened the way Wine opens the source failed (ret=%d, err=%d)\n", retok, GetLastError());
788 CloseHandle(hfile);
789
790 /* make sure that destination has correct size */
792 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
793 ret = GetFileSize(hfile, NULL);
794 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
795
796 /* make sure that destination has the same filetime */
797 ret = GetFileTime(hfile, NULL, NULL, &ft2);
798 ok( ret, "GetFileTime error %d\n", GetLastError());
799 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
800
801 SetLastError(0xdeadbeef);
804 "CopyFileA: ret = %d, unexpected error %d\n", ret, GetLastError());
805
806 /* make sure that destination still has correct size */
807 ret = GetFileSize(hfile, NULL);
808 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
809 retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
810 ok( retok && ret == sizeof(prefix),
811 "ReadFile: error %d\n", GetLastError());
812 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
813
814 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
815 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
816 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
817
820 "CopyFileA with mapped dest file: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
821
822 CloseHandle(hmapfile);
823 CloseHandle(hfile);
824
826 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
827
828 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
829 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
830 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
831
833 ok(!ret, "CopyFileA: expected failure\n");
836 "CopyFileA with mapped dest file: expected ERROR_USER_MAPPED_FILE, got %d\n", GetLastError());
837
838 CloseHandle(hmapfile);
839 CloseHandle(hfile);
840
842 ok(ret, "DeleteFileA: error %d\n", GetLastError());
844 ok(ret, "DeleteFileA: error %d\n", GetLastError());
845}
846
847static void test_CopyFileW(void)
848{
851 static const WCHAR prefix[] = {'p','f','x',0};
852 DWORD ret;
853
856 {
857 win_skip("GetTempPathW is not available\n");
858 return;
859 }
860 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
861 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
862
863 ret = GetTempFileNameW(temp_path, prefix, 0, source);
864 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
865
866 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
867 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
868
871 "CopyFileW: unexpected error %d\n", GetLastError());
872
874 ok(ret, "CopyFileW: error %d\n", GetLastError());
875
877 ok(ret, "DeleteFileW: error %d\n", GetLastError());
879 ok(ret, "DeleteFileW: error %d\n", GetLastError());
880}
881
882static void test_CopyFile2(void)
883{
884 static const WCHAR doesntexistW[] = {'d','o','e','s','n','t','e','x','i','s','t',0};
885 static const WCHAR prefix[] = {'p','f','x',0};
887 COPYFILE2_EXTENDED_PARAMETERS params;
888 HANDLE hfile, hmapfile;
889 FILETIME ft1, ft2;
890 DWORD ret, len;
891 char buf[10];
892 HRESULT hr;
893
894 if (!pCopyFile2)
895 {
896 skip("CopyFile2 is not available\n");
897 return;
898 }
899
901 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
902 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
903
904 ret = GetTempFileNameW(temp_path, prefix, 0, source);
905 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
906
907 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
908 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
909
910 /* fail if exists */
911 memset(&params, 0, sizeof(params));
912 params.dwSize = sizeof(params);
913 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
914
915 SetLastError(0xdeadbeef);
916 hr = pCopyFile2(source, dest, &params);
917 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
918 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
919
920 /* don't fail if exists */
921 params.dwSize = sizeof(params);
922 params.dwCopyFlags = 0;
923
924 hr = pCopyFile2(source, dest, &params);
925 ok(hr == S_OK, "CopyFile2: error 0x%08x\n", hr);
926
927 /* copying a file to itself must fail */
928 params.dwSize = sizeof(params);
929 params.dwCopyFlags = 0;
930
931 SetLastError(0xdeadbeef);
932 hr = pCopyFile2(source, source, &params);
933 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: copying a file to itself didn't fail, 0x%08x\n", hr);
934 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
935
936 /* make the source have not zero size */
937 hfile = CreateFileW(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
938 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
939 ret = WriteFile(hfile, prefix, sizeof(prefix), &len, NULL );
940 ok(ret && len == sizeof(prefix), "WriteFile error %d\n", GetLastError());
941 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
942
943 /* get the file time and change it to prove the difference */
944 ret = GetFileTime(hfile, NULL, NULL, &ft1);
945 ok(ret, "GetFileTime error %d\n", GetLastError());
946 ft1.dwLowDateTime -= 600000000; /* 60 second */
947 ret = SetFileTime(hfile, NULL, NULL, &ft1);
948 ok(ret, "SetFileTime error %d\n", GetLastError());
949 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
950 CloseHandle(hfile);
951
952 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
953 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
954
955 params.dwSize = sizeof(params);
956 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
957
958 SetLastError(0xdeadbeef);
959 hr = pCopyFile2(source, dest, &params);
960 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
961 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
962
963 params.dwSize = sizeof(params);
964 params.dwCopyFlags = 0;
965 hr = pCopyFile2(source, dest, &params);
966 ok(ret, "CopyFile2: error 0x%08x\n", hr);
967
968 /* copying from a read-locked source fails */
970 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
971
972 params.dwSize = sizeof(params);
973 params.dwCopyFlags = 0;
974 SetLastError(0xdeadbeef);
975 hr = pCopyFile2(source, dest, &params);
976 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
977 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
978
979 /* in addition, the source is opened before the destination */
980 params.dwSize = sizeof(params);
981 params.dwCopyFlags = 0;
982 SetLastError(0xdeadbeef);
983 hr = pCopyFile2(doesntexistW, dest, &params);
984 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
985 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "CopyFile2: last error %d\n", GetLastError());
986 CloseHandle(hfile);
987
988 /* copying from a r+w opened, r shared source succeeds */
990 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
991
992 params.dwSize = sizeof(params);
993 params.dwCopyFlags = 0;
994 hr = pCopyFile2(source, dest, &params);
995 ok(hr == S_OK, "failed 0x%08x\n", hr);
996 CloseHandle(hfile);
997
998 /* copying from a delete-locked source mostly succeeds */
1000 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
1001
1002 params.dwSize = sizeof(params);
1003 params.dwCopyFlags = 0;
1004 hr = pCopyFile2(source, dest, &params);
1005 ok(hr == S_OK, "failed 0x%08x\n", hr);
1006 CloseHandle(hfile);
1007
1008 /* copying to a write-locked destination fails */
1010 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1011
1012 params.dwSize = sizeof(params);
1013 params.dwCopyFlags = 0;
1014 SetLastError(0xdeadbeef);
1015 hr = pCopyFile2(source, dest, FALSE);
1016 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1017 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1018 CloseHandle(hfile);
1019
1020 /* copying to a r+w opened, w shared destination mostly succeeds */
1022 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1023
1024 params.dwSize = sizeof(params);
1025 params.dwCopyFlags = 0;
1026 hr = pCopyFile2(source, dest, FALSE);
1027 ok(hr == S_OK, "got 0x%08x\n", hr);
1028 CloseHandle(hfile);
1029
1030 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
1032 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1033
1034 params.dwSize = sizeof(params);
1035 params.dwCopyFlags = 0;
1036 SetLastError(0xdeadbeef);
1037 hr = pCopyFile2(source, dest, &params);
1038 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1039 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1040 CloseHandle(hfile);
1041
1042 /* copy to a file that's opened the way Wine opens the source */
1044 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1045
1046 params.dwSize = sizeof(params);
1047 params.dwCopyFlags = 0;
1048 hr = pCopyFile2(source, dest, &params);
1049 ok(hr == S_OK, "got 0x%08x\n", hr);
1050 CloseHandle(hfile);
1051
1052 /* make sure that destination has correct size */
1054 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1055 ret = GetFileSize(hfile, NULL);
1056 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1057
1058 /* make sure that destination has the same filetime */
1059 ret = GetFileTime(hfile, NULL, NULL, &ft2);
1060 ok(ret, "GetFileTime error %d\n", GetLastError());
1061 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
1062
1063 params.dwSize = sizeof(params);
1064 params.dwCopyFlags = 0;
1065 SetLastError(0xdeadbeef);
1066 hr = pCopyFile2(source, dest, &params);
1067 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1068 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1069
1070 /* make sure that destination still has correct size */
1071 ret = GetFileSize(hfile, NULL);
1072 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1073 ret = ReadFile(hfile, buf, sizeof(buf), &len, NULL);
1074 ok(ret && len == sizeof(prefix), "ReadFile: error %d\n", GetLastError());
1075 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
1076
1077 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
1078 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1079 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1080
1081 params.dwSize = sizeof(params);
1082 params.dwCopyFlags = 0;
1083 SetLastError(0xdeadbeef);
1084 hr = pCopyFile2(source, dest, &params);
1085 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1086 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1087
1088 CloseHandle(hmapfile);
1089 CloseHandle(hfile);
1090
1092 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1093
1094 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
1095 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1096 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1097
1098 params.dwSize = sizeof(params);
1099 params.dwCopyFlags = 0;
1100 hr = pCopyFile2(source, dest, &params);
1101 ok(hr == HRESULT_FROM_WIN32(ERROR_USER_MAPPED_FILE), "CopyFile2: unexpected error 0x%08x\n", hr);
1102 ok(GetLastError() == ERROR_USER_MAPPED_FILE, "CopyFile2: last error %d\n", GetLastError());
1103
1104 CloseHandle(hmapfile);
1105 CloseHandle(hfile);
1106
1109}
1110
1111static DWORD WINAPI copy_progress_cb(LARGE_INTEGER total_size, LARGE_INTEGER total_transferred,
1112 LARGE_INTEGER stream_size, LARGE_INTEGER stream_transferred,
1114{
1115 ok(reason == CALLBACK_STREAM_SWITCH, "expected CALLBACK_STREAM_SWITCH, got %u\n", reason);
1116 CloseHandle(userdata);
1117 return PROGRESS_CANCEL;
1118}
1119
1120static void test_CopyFileEx(void)
1121{
1122 char temp_path[MAX_PATH];
1123 char source[MAX_PATH], dest[MAX_PATH];
1124 static const char prefix[] = "pfx";
1125 HANDLE hfile;
1126 DWORD ret;
1127 BOOL retok;
1128
1130 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1131 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1132
1133 ret = GetTempFileNameA(temp_path, prefix, 0, source);
1134 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1135
1136 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
1137 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1138
1140 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1141 SetLastError(0xdeadbeef);
1142 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1143 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1144 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1145 ok(GetFileAttributesA(dest) != INVALID_FILE_ATTRIBUTES, "file was deleted\n");
1146
1148 NULL, OPEN_EXISTING, 0, 0);
1149 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1150 SetLastError(0xdeadbeef);
1151 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1152 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1153 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1154 ok(GetFileAttributesA(dest) == INVALID_FILE_ATTRIBUTES, "file was not deleted\n");
1155
1157 ok(ret, "DeleteFileA failed with error %d\n", GetLastError());
1158 ret = DeleteFileA(dest);
1159 ok(!ret, "DeleteFileA unexpectedly succeeded\n");
1160}
1161
1162/*
1163 * Debugging routine to dump a buffer in a hexdump-like fashion.
1164 */
1165static void dumpmem(unsigned char *mem, int len)
1166{
1167 int x = 0;
1168 char hex[49], *p;
1169 char txt[17], *c;
1170
1171 while (x < len)
1172 {
1173 p = hex;
1174 c = txt;
1175 do {
1176 p += sprintf(p, "%02x ", mem[x]);
1177 *c++ = (mem[x] >= 32 && mem[x] <= 127) ? mem[x] : '.';
1178 } while (++x % 16 && x < len);
1179 *c = '\0';
1180 trace("%04x: %-48s- %s\n", x, hex, txt);
1181 }
1182}
1183
1184static void test_CreateFileA(void)
1185{
1186 HANDLE hFile;
1188 char filename[MAX_PATH];
1189 static const char prefix[] = "pfx";
1190 char windowsdir[MAX_PATH];
1191 char Volume_1[MAX_PATH];
1192 unsigned char buffer[512];
1193 char directory[] = "removeme";
1194 static const char nt_drive[] = "\\\\?\\A:";
1195 DWORD i, ret, len;
1196 static const struct test_list p[] =
1197 {
1198 {"", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dir as file w \ */
1200 {"a", ERROR_FILE_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* non-exist file */
1202 {"removeme", ERROR_ACCESS_DENIED, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* exist dir w/o \ */
1203 {"removeme\\", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* exst dir w \ */
1204 {"c:", ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, FILE_ATTRIBUTE_NORMAL, FALSE }, /* device in file namespace */
1205 {"c:", ERROR_SUCCESS, ERROR_PATH_NOT_FOUND, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* device in file namespace as dir */
1206 {"c:\\", ERROR_PATH_NOT_FOUND, ERROR_ACCESS_DENIED, FILE_ATTRIBUTE_NORMAL, TRUE }, /* root dir w \ */
1207 {"c:\\", ERROR_SUCCESS, ERROR_ACCESS_DENIED, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* root dir w \ as dir */
1208 {"c:c:\\windows", ERROR_INVALID_NAME, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* invalid path */
1209 {"\\\\?\\c:", ERROR_SUCCESS, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL,FALSE }, /* dev namespace drive */
1210 {"\\\\?\\c:\\", ERROR_PATH_NOT_FOUND, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dev namespace drive w \ */
1211 {NULL, 0, -1, 0, FALSE}
1212 };
1214 WCHAR curdir[MAX_PATH];
1215
1217 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1218 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1219
1220 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
1221 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1222
1223 SetLastError(0xdeadbeef);
1227 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1228
1229 SetLastError(0xdeadbeef);
1233 "hFile %p, last error %u\n", hFile, GetLastError());
1234
1236
1237 SetLastError(0xdeadbeef);
1241 "hFile %p, last error %u\n", hFile, GetLastError());
1242
1244
1246 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1247
1248 SetLastError(0xdeadbeef);
1252 "hFile %p, last error %u\n", hFile, GetLastError());
1253
1255
1257 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1258
1259 SetLastError(0xdeadbeef);
1261 ok(hFile == INVALID_HANDLE_VALUE, "hFile should have been INVALID_HANDLE_VALUE\n");
1263 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* Win98 */
1264 "LastError should have been ERROR_INVALID_NAME or ERROR_FILE_NOT_FOUND but got %u\n", GetLastError());
1265
1266 /* get windows drive letter */
1267 ret = GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
1268 ok(ret < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1269 ok(ret != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1270
1271 /* test error return codes from CreateFile for some cases */
1273 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1277 ok( ret, "Createdirectory failed, gle=%d\n", GetLastError() );
1278 /* set current drive & directory to known location */
1281 i = 0;
1282 while (p[i].file)
1283 {
1284 filename[0] = 0;
1285 /* update the drive id in the table entry with the current one */
1286 if (p[i].file[1] == ':')
1287 {
1288 strcpy(filename, p[i].file);
1289 filename[0] = windowsdir[0];
1290 }
1291 else if (p[i].file[0] == '\\' && p[i].file[5] == ':')
1292 {
1293 strcpy(filename, p[i].file);
1294 filename[4] = windowsdir[0];
1295 }
1296 else
1297 {
1298 /* prefix the table entry with the current temp directory */
1300 strcat(filename, p[i].file);
1301 }
1305 p[i].options, NULL );
1306 /* if we get ACCESS_DENIED when we do not expect it, assume
1307 * no access to the volume
1308 */
1309 if (hFile == INVALID_HANDLE_VALUE &&
1312 {
1313 if (p[i].todo_flag)
1314 skip("Either no authority to volume, or is todo_wine for %s err=%d should be %d\n", filename, GetLastError(), p[i].err);
1315 else
1316 skip("Do not have authority to access volumes. Test for %s skipped\n", filename);
1317 }
1318 /* otherwise validate results with expectations */
1319 else
1320 {
1323 (p[i].err == GetLastError() || p[i].err2 == GetLastError())) ||
1325 "CreateFileA failed on %s, hFile %p, err=%u, should be %u\n",
1327 }
1329 CloseHandle( hFile );
1330 i++;
1331 }
1333 ok(ret, "RemoveDirectoryA: error %d\n", GetLastError());
1334 SetCurrentDirectoryW(curdir);
1335
1336 /* test opening directory as a directory */
1339 NULL,
1343 {
1345 "CreateFileA did not work, last error %u on volume <%s>\n",
1347
1349 {
1351 if (ret)
1352 {
1354 "CreateFileA probably did not open temp directory %s correctly\n file information does not include FILE_ATTRIBUTE_DIRECTORY, actual=0x%08x\n",
1356 }
1357 CloseHandle( hFile );
1358 }
1359 }
1360 else
1361 skip("Probable Win9x, got ERROR_PATH_NOT_FOUND w/ FILE_FLAG_BACKUP_SEMANTICS or %s\n", temp_path);
1362
1363
1364 /* *** Test opening volumes/devices using drive letter *** */
1365
1366 /* test using drive letter in non-rewrite format without trailing \ */
1367 /* this should work */
1368 strcpy(filename, nt_drive);
1369 filename[4] = windowsdir[0];
1374 if (hFile != INVALID_HANDLE_VALUE ||
1376 {
1377 /* if we have adm rights to volume, then try rest of tests */
1378 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1381 {
1382 /* if we opened the volume/device, try to read it. Since it */
1383 /* opened, we should be able to read it. We don't care about*/
1384 /* what the data is at this time. */
1385 len = 512;
1386 ret = ReadFile( hFile, buffer, len, &len, NULL );
1387 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1389 if (ret)
1390 {
1391 trace("buffer is\n");
1392 dumpmem(buffer, 64);
1393 }
1394 CloseHandle( hFile );
1395 }
1396
1397 /* test using drive letter with trailing \ and in non-rewrite */
1398 /* this should not work */
1399 strcpy(filename, nt_drive);
1400 filename[4] = windowsdir[0];
1401 strcat( filename, "\\" );
1406 todo_wine
1408 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1411 CloseHandle( hFile );
1412
1413 /* test using temp path with trailing \ and in non-rewrite as dir */
1414 /* this should work */
1415 strcpy(filename, nt_drive);
1416 filename[4] = 0;
1423 "CreateFileA should have worked on %s, but got %u\n",
1426 CloseHandle( hFile );
1427
1428 /* test using drive letter without trailing \ and in device ns */
1429 /* this should work */
1430 strcpy(filename, nt_drive);
1431 filename[4] = windowsdir[0];
1432 filename[2] = '.';
1437 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1440 CloseHandle( hFile );
1441 }
1442 /* If we see ERROR_BAD_NETPATH then on Win9x or WinME, so skip */
1443 else if (GetLastError() == ERROR_BAD_NETPATH)
1444 skip("Probable Win9x, got ERROR_BAD_NETPATH (53)\n");
1445 else
1446 skip("Do not have authority to access volumes. Tests skipped\n");
1447
1448
1449 /* *** Test opening volumes/devices using GUID *** */
1450
1451 if (pGetVolumeNameForVolumeMountPointA)
1452 {
1453 strcpy(filename, "c:\\");
1454 filename[0] = windowsdir[0];
1455 ret = pGetVolumeNameForVolumeMountPointA( filename, Volume_1, MAX_PATH );
1456 ok(ret, "GetVolumeNameForVolumeMountPointA failed, for %s, last error=%d\n", filename, GetLastError());
1457 if (ret)
1458 {
1459 ok(strlen(Volume_1) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name <%s>\n", Volume_1);
1460
1461 /* test the result of opening a unique volume name (GUID)
1462 * with the trailing \
1463 * this should error out
1464 */
1465 strcpy(filename, Volume_1);
1470 todo_wine
1472 "CreateFileA should not have opened %s, hFile %p\n",
1473 filename, hFile);
1474 todo_wine
1476 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1479 CloseHandle( hFile );
1480
1481 /* test the result of opening a unique volume name (GUID)
1482 * with the temp path string as dir
1483 * this should work
1484 */
1485 strcpy(filename, Volume_1);
1491 todo_wine
1493 "CreateFileA should have opened %s, but got %u\n",
1496 CloseHandle( hFile );
1497
1498 /* test the result of opening a unique volume name (GUID)
1499 * without the trailing \ and in device namespace
1500 * this should work
1501 */
1502 strcpy(filename, Volume_1);
1503 filename[2] = '.';
1504 filename[48] = 0;
1510 {
1511 /* if we have adm rights to volume, then try rest of tests */
1512 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1515 {
1516 /* if we opened the volume/device, try to read it. Since it */
1517 /* opened, we should be able to read it. We don't care about*/
1518 /* what the data is at this time. */
1519 len = 512;
1520 ret = ReadFile( hFile, buffer, len, &len, NULL );
1521 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1523 if (ret)
1524 {
1525 trace("buffer is\n");
1526 dumpmem(buffer, 64);
1527 }
1528 CloseHandle( hFile );
1529 }
1530 }
1531 else
1532 skip("Do not have authority to access volumes. Tests skipped\n");
1533 }
1534 else
1535 win_skip("GetVolumeNameForVolumeMountPointA not functioning\n");
1536 }
1537 else
1538 win_skip("GetVolumeNameForVolumeMountPointA not found\n");
1539}
1540
1541static void test_CreateFileW(void)
1542{
1543 HANDLE hFile;
1546 static const WCHAR emptyW[]={'\0'};
1547 static const WCHAR prefix[] = {'p','f','x',0};
1548 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1549 DWORD ret;
1550
1553 {
1554 win_skip("GetTempPathW is not available\n");
1555 return;
1556 }
1557 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1558 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1559
1560 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1561 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1562
1563 SetLastError(0xdeadbeef);
1567 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1568
1569 SetLastError(0xdeadbeef);
1573 "hFile %p, last error %u\n", hFile, GetLastError());
1574
1576
1577 SetLastError(0xdeadbeef);
1581 "hFile %p, last error %u\n", hFile, GetLastError());
1582
1584
1586 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1587
1588 SetLastError(0xdeadbeef);
1592 "hFile %p, last error %u\n", hFile, GetLastError());
1593
1595
1597 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1598
1599 if (0)
1600 {
1601 /* this crashes on NT4.0 */
1605 "CreateFileW(NULL) returned ret=%p error=%u\n",hFile,GetLastError());
1606 }
1607
1611 "CreateFileW(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1612
1613 /* test the result of opening a nonexistent driver name */
1617 "CreateFileW on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1618
1620 ok(ret == TRUE, "couldn't create temporary directory\n");
1624 "expected CreateFile to succeed on existing directory, error: %d\n", GetLastError());
1627 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1628}
1629
1630static void test_CreateFile2(void)
1631{
1632 HANDLE hFile;
1636 static const WCHAR emptyW[]={'\0'};
1637 static const WCHAR prefix[] = {'p','f','x',0};
1638 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1639 DWORD ret;
1640
1641 if (!pCreateFile2)
1642 {
1643 win_skip("CreateFile2 is missing\n");
1644 return;
1645 }
1646
1648 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1649 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1650
1651 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1652 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1653
1654 SetLastError(0xdeadbeef);
1655 exparams.dwSize = sizeof(exparams);
1657 exparams.dwFileFlags = 0;
1658 exparams.dwSecurityQosFlags = 0;
1659 exparams.lpSecurityAttributes = NULL;
1660 exparams.hTemplateFile = 0;
1661 hFile = pCreateFile2(filename, GENERIC_READ, 0, CREATE_NEW, &exparams);
1663 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1664
1665 SetLastError(0xdeadbeef);
1666 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, CREATE_ALWAYS, &exparams);
1668 "hFile %p, last error %u\n", hFile, GetLastError());
1670
1671 SetLastError(0xdeadbeef);
1672 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1674 "hFile %p, last error %u\n", hFile, GetLastError());
1676
1678 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1679
1680 SetLastError(0xdeadbeef);
1681 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1683 "hFile %p, last error %u\n", hFile, GetLastError());
1685
1687 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1688
1689 hFile = pCreateFile2(emptyW, GENERIC_READ, 0, CREATE_NEW, &exparams);
1691 "CreateFile2(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1692
1693 /* test the result of opening a nonexistent driver name */
1695 hFile = pCreateFile2(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING, &exparams);
1697 "CreateFile2 on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1698
1700 ok(ret == TRUE, "couldn't create temporary directory\n");
1702 hFile = pCreateFile2(filename, GENERIC_READ | GENERIC_WRITE, 0, OPEN_ALWAYS, &exparams);
1703 todo_wine
1705 "expected CreateFile2 to fail on existing directory, error: %d\n", GetLastError());
1708 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1709}
1710
1711static void test_GetTempFileNameA(void)
1712{
1713 UINT result;
1714 char out[MAX_PATH];
1715 char expected[MAX_PATH + 10];
1716 char windowsdir[MAX_PATH + 10];
1717 char windowsdrive[3];
1718
1719 result = GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
1720 ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1721 ok(result != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1722
1723 /* If the Windows directory is the root directory, it ends in backslash, not else. */
1724 if (strlen(windowsdir) != 3) /* As in "C:\" or "F:\" */
1725 {
1726 strcat(windowsdir, "\\");
1727 }
1728
1729 windowsdrive[0] = windowsdir[0];
1730 windowsdrive[1] = windowsdir[1];
1731 windowsdrive[2] = '\0';
1732
1733 result = GetTempFileNameA(windowsdrive, "abc", 1, out);
1734 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1735 ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
1736 "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
1737 windowsdrive[0], out);
1738
1739 result = GetTempFileNameA(windowsdir, "abc", 2, out);
1740 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1741 expected[0] = '\0';
1742 strcat(expected, windowsdir);
1743 strcat(expected, "abc2.tmp");
1744 ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
1745 out, expected);
1746}
1747
1748static void test_DeleteFileA( void )
1749{
1750 BOOL ret;
1752 HANDLE hfile;
1753
1754 ret = DeleteFileA(NULL);
1757 "DeleteFileA(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1758
1759 ret = DeleteFileA("");
1762 "DeleteFileA(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1763
1764 ret = DeleteFileA("nul");
1769 "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret,GetLastError());
1770
1771 ret = DeleteFileA("nonexist.txt");
1772 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "DeleteFileA(\"nonexist.txt\") returned ret=%d error=%d\n",ret,GetLastError());
1773
1776
1777 SetLastError(0xdeadbeef);
1779 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
1780
1781 SetLastError(0xdeadbeef);
1783 ok(ret, "DeleteFile error %d\n", GetLastError());
1784
1785 SetLastError(0xdeadbeef);
1786 ret = CloseHandle(hfile);
1787 ok(ret, "CloseHandle error %d\n", GetLastError());
1789 ok(!ret, "DeleteFile should fail\n");
1790
1791 SetLastError(0xdeadbeef);
1792 ret = CreateDirectoryA("testdir", NULL);
1793 ok(ret, "CreateDirectory failed, got err %d\n", GetLastError());
1794 ret = DeleteFileA("testdir");
1796 "Expected ERROR_ACCESS_DENIED, got error %d\n", GetLastError());
1797 ret = RemoveDirectoryA("testdir");
1798 ok(ret, "Remove a directory failed, got error %d\n", GetLastError());
1799}
1800
1801static void test_DeleteFileW( void )
1802{
1803 BOOL ret;
1804 WCHAR pathW[MAX_PATH];
1805 WCHAR pathsubW[MAX_PATH];
1806 static const WCHAR dirW[] = {'d','e','l','e','t','e','f','i','l','e',0};
1807 static const WCHAR subdirW[] = {'\\','s','u','b',0};
1808 static const WCHAR emptyW[]={'\0'};
1809
1810 ret = DeleteFileW(NULL);
1812 {
1813 win_skip("DeleteFileW is not available\n");
1814 return;
1815 }
1817 "DeleteFileW(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1818
1821 "DeleteFileW(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1822
1823 /* test DeleteFile on empty directory */
1824 ret = GetTempPathW(MAX_PATH, pathW);
1825 if (ret + sizeof(dirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
1826 {
1827 ok(0, "MAX_PATH exceeded in constructing paths\n");
1828 return;
1829 }
1830 lstrcatW(pathW, dirW);
1831 lstrcpyW(pathsubW, pathW);
1832 lstrcatW(pathsubW, subdirW);
1833 ret = CreateDirectoryW(pathW, NULL);
1834 ok(ret == TRUE, "couldn't create directory deletefile\n");
1835 ret = DeleteFileW(pathW);
1836 ok(ret == FALSE, "DeleteFile should fail for empty directories\n");
1837 ret = RemoveDirectoryW(pathW);
1838 ok(ret == TRUE, "expected to remove directory deletefile\n");
1839
1840 /* test DeleteFile on non-empty directory */
1841 ret = CreateDirectoryW(pathW, NULL);
1842 ok(ret == TRUE, "couldn't create directory deletefile\n");
1843 ret = CreateDirectoryW(pathsubW, NULL);
1844 ok(ret == TRUE, "couldn't create directory deletefile\\sub\n");
1845 ret = DeleteFileW(pathW);
1846 ok(ret == FALSE, "DeleteFile should fail for non-empty directories\n");
1847 ret = RemoveDirectoryW(pathsubW);
1848 ok(ret == TRUE, "expected to remove directory deletefile\\sub\n");
1849 ret = RemoveDirectoryW(pathW);
1850 ok(ret == TRUE, "expected to remove directory deletefile\n");
1851}
1852
1853#define IsDotDir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
1854
1855static void test_MoveFileA(void)
1856{
1857 char tempdir[MAX_PATH];
1858 char source[MAX_PATH], dest[MAX_PATH];
1859 static const char prefix[] = "pfx";
1860 HANDLE hfile;
1861 HANDLE hmapfile;
1862 DWORD ret;
1863 BOOL retok;
1864
1865 ret = GetTempPathA(MAX_PATH, tempdir);
1866 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1867 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1868
1869 ret = GetTempFileNameA(tempdir, prefix, 0, source);
1870 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1871
1872 ret = GetTempFileNameA(tempdir, prefix, 0, dest);
1873 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1874
1876 ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
1877
1880 "MoveFileA: unexpected error %d\n", GetLastError());
1881
1882 ret = DeleteFileA(dest);
1883 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1884
1886 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1887
1888 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
1889 ok( retok && ret == sizeof(prefix),
1890 "WriteFile error %d\n", GetLastError());
1891
1892 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1893 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1894
1896 ok(!ret, "MoveFileA: expected failure\n");
1898 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1899 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1900
1901 CloseHandle(hmapfile);
1902 CloseHandle(hfile);
1903
1904 /* if MoveFile succeeded, move back to dest */
1905 if (ret) MoveFileA(dest, source);
1906
1908 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1909
1910 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1911 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1912
1914 ok(!ret, "MoveFileA: expected failure\n");
1916 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1917 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1918
1919 CloseHandle(hmapfile);
1920 CloseHandle(hfile);
1921
1922 /* if MoveFile succeeded, move back to dest */
1923 if (ret) MoveFileA(dest, source);
1924
1926 ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
1927
1928 lstrcatA(tempdir, "Remove Me");
1929 ret = CreateDirectoryA(tempdir, NULL);
1930 ok(ret == TRUE, "CreateDirectoryA failed\n");
1931
1933 lstrcpyA(dest, tempdir);
1934 lstrcatA(dest, "\\wild?.*");
1935 /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
1937 ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
1938 ok(GetLastError() == ERROR_INVALID_NAME || /* NT */
1939 GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x */
1940 "MoveFileA: with wildcards, unexpected error %d\n", GetLastError());
1941 if (ret || (GetLastError() != ERROR_INVALID_NAME))
1942 {
1944 char temppath[MAX_PATH];
1945 HANDLE hFind;
1946
1947 lstrcpyA(temppath, tempdir);
1948 lstrcatA(temppath, "\\*.*");
1949 hFind = FindFirstFileA(temppath, &fd);
1950 if (INVALID_HANDLE_VALUE != hFind)
1951 {
1952 LPSTR lpName;
1953 do
1954 {
1955 lpName = fd.cAlternateFileName;
1956 if (!lpName[0])
1957 lpName = fd.cFileName;
1958 ok(IsDotDir(lpName), "MoveFileA: wildcards file created!\n");
1959 }
1960 while (FindNextFileA(hFind, &fd));
1961 FindClose(hFind);
1962 }
1963 }
1965 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1966 ret = DeleteFileA(dest);
1967 ok(!ret, "DeleteFileA: error %d\n", GetLastError());
1968 ret = RemoveDirectoryA(tempdir);
1969 ok(ret, "DeleteDirectoryA: error %d\n", GetLastError());
1970}
1971
1972static void test_MoveFileW(void)
1973{
1976 static const WCHAR prefix[] = {'p','f','x',0};
1977 DWORD ret;
1978
1981 {
1982 win_skip("GetTempPathW is not available\n");
1983 return;
1984 }
1985 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1986 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1987
1988 ret = GetTempFileNameW(temp_path, prefix, 0, source);
1989 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1990
1991 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
1992 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1993
1996 "CopyFileW: unexpected error %d\n", GetLastError());
1997
1999 ok(ret, "DeleteFileW: error %d\n", GetLastError());
2000 ret = DeleteFileW(dest);
2001 ok(ret, "DeleteFileW: error %d\n", GetLastError());
2002}
2003
2004#define PATTERN_OFFSET 0x10
2005
2007{
2008 HANDLE hFile;
2009 OVERLAPPED ov;
2010 DWORD done, offset;
2011 BOOL rc;
2012 BYTE buf[256], pattern[] = "TeSt";
2013 UINT i;
2014 char temp_path[MAX_PATH], temp_fname[MAX_PATH];
2015 BOOL ret;
2016
2018 ok( ret, "GetTempPathA error %d\n", GetLastError());
2019 ret =GetTempFileNameA(temp_path, "pfx", 0, temp_fname);
2020 ok( ret, "GetTempFileNameA error %d\n", GetLastError());
2021
2022 /*** Write File *****************************************************/
2023
2025 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
2026
2027 for(i = 0; i < sizeof(buf); i++) buf[i] = i;
2028 ret = WriteFile(hFile, buf, sizeof(buf), &done, NULL);
2029 ok( ret, "WriteFile error %d\n", GetLastError());
2030 ok(done == sizeof(buf), "expected number of bytes written %u\n", done);
2031
2032 memset(&ov, 0, sizeof(ov));
2033 S(U(ov)).Offset = PATTERN_OFFSET;
2034 S(U(ov)).OffsetHigh = 0;
2035 rc=WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
2036 /* Win 9x does not support the overlapped I/O on files */
2038 ok(rc, "WriteFile error %d\n", GetLastError());
2039 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
2041 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
2042
2043 S(U(ov)).Offset = sizeof(buf) * 2;
2044 S(U(ov)).OffsetHigh = 0;
2045 ret = WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
2046 ok( ret, "WriteFile error %d\n", GetLastError());
2047 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
2049 ok(offset == sizeof(buf) * 2 + sizeof(pattern), "wrong file offset %d\n", offset);
2050 }
2051
2053
2054 /*** Read File *****************************************************/
2055
2056 hFile = CreateFileA(temp_fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
2057 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
2058
2059 memset(buf, 0, sizeof(buf));
2060 memset(&ov, 0, sizeof(ov));
2061 S(U(ov)).Offset = PATTERN_OFFSET;
2062 S(U(ov)).OffsetHigh = 0;
2063 rc=ReadFile(hFile, buf, sizeof(pattern), &done, &ov);
2064 /* Win 9x does not support the overlapped I/O on files */
2066 ok(rc, "ReadFile error %d\n", GetLastError());
2067 ok(done == sizeof(pattern), "expected number of bytes read %u\n", done);
2069 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
2070 ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
2071 }
2072
2074
2075 ret = DeleteFileA(temp_fname);
2076 ok( ret, "DeleteFileA error %d\n", GetLastError());
2077}
2078
2079static void test_LockFile(void)
2080{
2081 HANDLE handle, handle2;
2082 DWORD written;
2084 int limited_LockFile;
2085 int limited_UnLockFile;
2086 BOOL ret;
2087
2090 CREATE_ALWAYS, 0, 0 );
2092 {
2093 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2094 return;
2095 }
2098 OPEN_EXISTING, 0, 0 );
2099 if (handle2 == INVALID_HANDLE_VALUE)
2100 {
2101 ok( 0, "couldn't open file \"%s\" (err=%d)\n", filename, GetLastError() );
2102 goto cleanup;
2103 }
2104 ok( WriteFile( handle, sillytext, strlen(sillytext), &written, NULL ), "write failed\n" );
2105
2106 ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
2107 ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
2108
2109 limited_UnLockFile = 0;
2110 if (UnlockFile( handle, 0, 0, 0, 0 ))
2111 {
2112 limited_UnLockFile = 1;
2113 }
2114
2115 ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
2116 /* overlapping locks must fail */
2117 ok( !LockFile( handle, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
2118 ok( !LockFile( handle, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
2119 /* non-overlapping locks must succeed */
2120 ok( LockFile( handle, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
2121
2122 ok( !UnlockFile( handle, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
2123 ok( UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
2124 ok( !UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
2125 ok( UnlockFile( handle, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
2126
2127 S(U(overlapped)).Offset = 100;
2128 S(U(overlapped)).OffsetHigh = 0;
2129 overlapped.hEvent = 0;
2130
2131 /* Test for broken LockFileEx a la Windows 95 OSR2. */
2132 if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
2133 {
2134 /* LockFileEx is probably OK, test it more. */
2135 ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
2136 "LockFileEx 100,100 failed\n" );
2137 }
2138
2139 /* overlapping shared locks are OK */
2140 S(U(overlapped)).Offset = 150;
2141 limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
2142
2143 /* but exclusive is not */
2145 0, 50, 0, &overlapped ),
2146 "LockFileEx exclusive 150,50 succeeded\n" );
2147 if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
2148 { /* UnLockFile is capable. */
2149 S(U(overlapped)).Offset = 100;
2150 ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
2151 "UnlockFileEx 150,100 again succeeded\n" );
2152 }
2153
2154 /* shared lock can overlap exclusive if handles are equal */
2155 S(U(overlapped)).Offset = 300;
2157 "LockFileEx exclusive 300,100 failed\n" );
2158 ok( !LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
2159 "LockFileEx handle2 300,100 succeeded\n" );
2161 ok( ret, "LockFileEx 300,100 failed\n" );
2162 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2163 /* exclusive lock is removed first */
2164 ok( LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
2165 "LockFileEx handle2 300,100 failed\n" );
2166 ok( UnlockFileEx( handle2, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2167 if (ret)
2168 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2169
2170 ret = LockFile( handle, 0, 0x10000000, 0, 0xf0000000 );
2171 if (ret)
2172 {
2173 ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
2174 ok( !LockFile( handle, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
2175 ok( UnlockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
2176 }
2177 else /* win9x */
2178 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong LockFile error %u\n", GetLastError() );
2179
2180 /* wrap-around lock should not do anything */
2181 /* (but still succeeds on NT4 so we don't check result) */
2182 LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
2183
2184 limited_LockFile = 0;
2185 if (!LockFile( handle, ~0, ~0, 1, 0 ))
2186 {
2187 limited_LockFile = 1;
2188 }
2189
2190 limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
2191
2192 /* zero-byte lock */
2193 ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
2194 if (!limited_LockFile) ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
2195 ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
2196 if (!limited_LockFile) ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
2197
2198 ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
2199 ok( !UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 succeeded\n" );
2200
2201 ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
2202
2203 CloseHandle( handle2 );
2204cleanup:
2207}
2208
2210{
2214 BYTE *buffer;
2215 DWORD lfanew = sizeof(*dos);
2216 DWORD size = lfanew + sizeof(*nt) + sizeof(*sec);
2217 DWORD written;
2218 BOOL ret;
2219
2221 if (file == INVALID_HANDLE_VALUE) return FALSE;
2222
2224
2227 dos->e_cblp = sizeof(*dos);
2228 dos->e_cp = 1;
2229 dos->e_cparhdr = lfanew / 16;
2230 dos->e_minalloc = 0;
2231 dos->e_maxalloc = 0xffff;
2232 dos->e_ss = 0x0000;
2233 dos->e_sp = 0x00b8;
2234 dos->e_lfarlc = lfanew;
2235 dos->e_lfanew = lfanew;
2236
2237 nt = (IMAGE_NT_HEADERS *)(buffer + lfanew);
2239#if defined __i386__
2241#elif defined __x86_64__
2243#elif defined __powerpc__
2245#elif defined __arm__
2247#elif defined __aarch64__
2249#else
2250# error You must specify the machine type
2251#endif
2258 nt->OptionalHeader.ImageBase = 0x10000000;
2267 nt->OptionalHeader.SizeOfImage = 0x2000;
2271
2272 sec = (IMAGE_SECTION_HEADER *)(nt + 1);
2273 memcpy( sec->Name, ".rodata", sizeof(".rodata") );
2274 sec->Misc.VirtualSize = 0x1000;
2275 sec->VirtualAddress = 0x1000;
2276 sec->SizeOfRawData = 0;
2277 sec->PointerToRawData = 0;
2279
2280 ret = WriteFile( file, buffer, size, &written, NULL ) && written == size;
2282 CloseHandle( file );
2283 return ret;
2284}
2285
2286static unsigned int map_file_access( unsigned int access )
2287{
2293}
2294
2295static BOOL is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2 )
2296{
2297 access1 = map_file_access( access1 );
2298 access2 = map_file_access( access2 );
2301
2302 if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2303 if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2304
2305 if ((access1 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing2 & FILE_SHARE_READ)) return FALSE;
2306 if ((access1 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2307 if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return FALSE;
2308 if ((access2 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing1 & FILE_SHARE_READ)) return FALSE;
2309 if ((access2 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing1 & FILE_SHARE_WRITE)) return FALSE;
2310 if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return FALSE;
2311 return TRUE;
2312}
2313
2314static BOOL is_sharing_map_compatible( DWORD map_access, DWORD access2, DWORD sharing2 )
2315{
2316 if ((map_access == PAGE_READWRITE || map_access == PAGE_EXECUTE_READWRITE) &&
2317 !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2318 access2 = map_file_access( access2 );
2319 if ((map_access & SEC_IMAGE) && (access2 & FILE_WRITE_DATA)) return FALSE;
2320 return TRUE;
2321}
2322
2323static void test_file_sharing(void)
2324{
2325 struct mode { DWORD dw; const char* str; };
2326#define M(x) {x, # x}
2327 static const struct mode access_modes[] =
2335 static const struct mode sharing_modes[] =
2336 { M(0), M(FILE_SHARE_READ),
2340 static const struct mode mapping_modes[] =
2342#undef M
2343 int a1, s1, a2, s2;
2344 int ret;
2345 HANDLE h, h2;
2346
2347 /* make sure the file exists */
2348 if (!create_fake_dll( filename ))
2349 {
2350 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
2351 return;
2352 }
2353
2354 for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
2355 {
2356 for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
2357 {
2358 SetLastError(0xdeadbeef);
2359 h = CreateFileA( filename, access_modes[a1].dw, sharing_modes[s1].dw,
2360 NULL, OPEN_EXISTING, 0, 0 );
2361 if (h == INVALID_HANDLE_VALUE)
2362 {
2363 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2364 return;
2365 }
2366 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2367 {
2368 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2369 {
2370 SetLastError(0xdeadbeef);
2371 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2372 NULL, OPEN_EXISTING, 0, 0 );
2373 ret = GetLastError();
2374 if (is_sharing_compatible( access_modes[a1].dw, sharing_modes[s1].dw,
2375 access_modes[a2].dw, sharing_modes[s2].dw ))
2376 {
2377 ok( h2 != INVALID_HANDLE_VALUE,
2378 "open failed for modes %s / %s / %s / %s\n",
2379 access_modes[a1].str, sharing_modes[s1].str,
2380 access_modes[a2].str, sharing_modes[s2].str );
2381 ok( ret == 0, "wrong error code %d\n", ret );
2382 }
2383 else
2384 {
2385 ok( h2 == INVALID_HANDLE_VALUE,
2386 "open succeeded for modes %s / %s / %s / %s\n",
2387 access_modes[a1].str, sharing_modes[s1].str,
2388 access_modes[a2].str, sharing_modes[s2].str );
2390 "wrong error code %d\n", ret );
2391 }
2392 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2393 }
2394 }
2395 CloseHandle( h );
2396 }
2397 }
2398
2399 for (a1 = 0; a1 < sizeof(mapping_modes)/sizeof(mapping_modes[0]); a1++)
2400 {
2401 HANDLE m;
2402
2404 SetLastError(0xdeadbeef);
2406 if (h == INVALID_HANDLE_VALUE)
2407 {
2408 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2409 return;
2410 }
2411 m = CreateFileMappingA( h, NULL, mapping_modes[a1].dw, 0, 0, NULL );
2412 ok( m != 0, "failed to create mapping %s err %u\n", mapping_modes[a1].str, GetLastError() );
2413 CloseHandle( h );
2414 if (!m) continue;
2415
2416 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2417 {
2418 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2419 {
2420 SetLastError(0xdeadbeef);
2421 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2422 NULL, OPEN_EXISTING, 0, 0 );
2423
2424 ret = GetLastError();
2425 if (h2 == INVALID_HANDLE_VALUE)
2426 {
2427 ok( !is_sharing_map_compatible(mapping_modes[a1].dw, access_modes[a2].dw, sharing_modes[s2].dw),
2428 "open failed for modes map %s / %s / %s\n",
2429 mapping_modes[a1].str, access_modes[a2].str, sharing_modes[s2].str );
2431 "wrong error code %d\n", ret );
2432 }
2433 else
2434 {
2435 if (!is_sharing_map_compatible(mapping_modes[a1].dw, access_modes[a2].dw, sharing_modes[s2].dw))
2436 ok( broken(1), /* no checking on nt4 */
2437 "open succeeded for modes map %s / %s / %s\n",
2438 mapping_modes[a1].str, access_modes[a2].str, sharing_modes[s2].str );
2439 ok( ret == 0xdeadbeef /* Win9x */ ||
2440 ret == 0, /* XP */
2441 "wrong error code %d\n", ret );
2442 CloseHandle( h2 );
2443 }
2444 }
2445 }
2446
2447 /* try CREATE_ALWAYS over an existing mapping */
2448 SetLastError(0xdeadbeef);
2450 NULL, CREATE_ALWAYS, 0, 0 );
2451 ret = GetLastError();
2452 if (mapping_modes[a1].dw & SEC_IMAGE)
2453 {
2454 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2455 ok( ret == ERROR_SHARING_VIOLATION, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2456 }
2457 else
2458 {
2459 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2460 ok( ret == ERROR_USER_MAPPED_FILE, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2461 }
2462 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2463
2464 /* try DELETE_ON_CLOSE over an existing mapping */
2465 SetLastError(0xdeadbeef);
2468 ret = GetLastError();
2469 if (mapping_modes[a1].dw & SEC_IMAGE)
2470 {
2471 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2472 ok( ret == ERROR_ACCESS_DENIED, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2473 }
2474 else
2475 {
2476 ok( h2 != INVALID_HANDLE_VALUE, "open failed for map %s err %u\n", mapping_modes[a1].str, ret );
2477 }
2478 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2479
2480 CloseHandle( m );
2481 }
2482
2483 SetLastError(0xdeadbeef);
2485 ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
2486
2487 SetLastError(0xdeadbeef);
2489 ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
2490 ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %d\n", GetLastError() );
2491
2493 ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
2494
2495 CloseHandle(h);
2496 CloseHandle(h2);
2497
2499}
2500
2501static char get_windows_drive(void)
2502{
2503 char windowsdir[MAX_PATH];
2504 GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
2505 return windowsdir[0];
2506}
2507
2508static const struct
2509{
2510 const char *path;
2512}
2514{
2515 { "./test-dir", TRUE },
2516 { "./test-dir/", FALSE },
2517 { ".\\test-dir", TRUE },
2518 { ".\\test-dir\\", FALSE },
2519 { "/>test-dir", FALSE },
2520 { "<\"test->dir", FALSE },
2521 { "<test->dir", FALSE },
2522 { "><test->dir", FALSE },
2523 { ">>test-dir", FALSE },
2524 { ">test->dir", FALSE },
2525 { ">test-dir", FALSE },
2526 { "\"test-dir\"", FALSE },
2527 { "\"test-file\"", FALSE },
2528 { "test-/>dir", FALSE },
2529 { "test-dir/", FALSE },
2530 { "test-dir//", FALSE },
2531 { "test-dir/:", FALSE },
2532 { "test-dir/<", TRUE },
2533 { "test-dir/>", TRUE },
2534 { "test-dir/\"", TRUE },
2535 { "test-dir/\\", FALSE },
2536 { "test-dir/|", FALSE },
2537 { "test-dir<", TRUE },
2538 { "test-dir</", FALSE },
2539 { "test-dir<<", TRUE },
2540 { "test-dir<<<><><>\"\"\"\"<<<>", TRUE },
2541 { "test-dir<>", TRUE },
2542 { "test-dir<\"", TRUE },
2543 { "test-dir>", TRUE },
2544 { "test-dir>/", FALSE },
2545 { "test-dir><", TRUE },
2546 { "test-dir>>", TRUE },
2547 { "test-dir>\"", TRUE },
2548 { "test-dir\"", TRUE },
2549 { "test-dir\"/", FALSE },
2550 { "test-dir\"<", TRUE },
2551 { "test-dir\">", TRUE },
2552 { "test-dir\"\"", TRUE },
2553 { "test-dir\"\"\"\"\"", TRUE },
2554 { "test-dir\\", FALSE },
2555 { "test-dir\\/", FALSE },
2556 { "test-dir\\<", TRUE },
2557 { "test-dir\\>", TRUE },
2558 { "test-dir\\\"", TRUE },
2559 { "test-dir\\\\", FALSE },
2560 { "test-file/", FALSE },
2561 { "test-file/<", FALSE },
2562 { "test-file/>", FALSE },
2563 { "test-file/\"", FALSE },
2564 { "test-file<", TRUE },
2565 { "test-file<<", TRUE },
2566 { "test-file<>", TRUE },
2567 { "test-file<\"", TRUE },
2568 { "test-file>", TRUE },
2569 { "test-file><", TRUE },
2570 { "test-file>>", TRUE },
2571 { "test-file>\"", TRUE },
2572 { "test-file\"", TRUE },
2573 { "test-file\"<", TRUE },
2574 { "test-file\">", TRUE },
2575 { "test-file\"\"", TRUE },
2576 { "test-file\\", FALSE },
2577 { "test-file\\<", FALSE },
2578 { "test-file\\>", FALSE },
2579 { "test-file\\\"", FALSE },
2581
2582static void test_FindFirstFileA(void)
2583{
2584 HANDLE handle;
2586 int err, i;
2587 char buffer[5] = "C:\\";
2588 char buffer2[100];
2589 char nonexistent[MAX_PATH];
2590
2591 /* try FindFirstFileA on "C:\" */
2593
2594 SetLastError( 0xdeadbeaf );
2596 err = GetLastError();
2597 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on root directory should fail\n" );
2598 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2599
2600 /* try FindFirstFileA on "C:\*" */
2601 strcpy(buffer2, buffer);
2602 strcat(buffer2, "*");
2603 handle = FindFirstFileA(buffer2, &data);
2604 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2605 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2606 "FindFirstFile shouldn't return '%s' in drive root\n", data.cFileName );
2607 if (FindNextFileA( handle, &data ))
2608 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2609 "FindNextFile shouldn't return '%s' in drive root\n", data.cFileName );
2610 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2611
2612 /* try FindFirstFileA on windows dir */
2613 GetWindowsDirectoryA( buffer2, sizeof(buffer2) );
2614 strcat(buffer2, "\\*");
2615 handle = FindFirstFileA(buffer2, &data);
2616 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2617 ok( !strcmp( data.cFileName, "." ), "FindFirstFile should return '.' first\n" );
2618 ok( FindNextFileA( handle, &data ), "FindNextFile failed\n" );
2619 ok( !strcmp( data.cFileName, ".." ), "FindNextFile should return '..' as second entry\n" );
2620 while (FindNextFileA( handle, &data ))
2621 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2622 "FindNextFile shouldn't return '%s'\n", data.cFileName );
2623 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2624
2625 /* try FindFirstFileA on "C:\foo\" */
2626 SetLastError( 0xdeadbeaf );
2628 {
2629 char tmp[MAX_PATH];
2630 GetTempPathA( sizeof(tmp), tmp );
2631 GetTempFileNameA( tmp, "foo", 0, nonexistent );
2632 }
2634 strcpy(buffer2, nonexistent);
2635 strcat(buffer2, "\\");
2636 handle = FindFirstFileA(buffer2, &data);
2637 err = GetLastError();
2638 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2639 todo_wine {
2640 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2641 }
2642
2643 /* try FindFirstFileA without trailing backslash */
2644 SetLastError( 0xdeadbeaf );
2645 strcpy(buffer2, nonexistent);
2646 handle = FindFirstFileA(buffer2, &data);
2647 err = GetLastError();
2648 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2649 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2650
2651 /* try FindFirstFileA on "C:\foo\bar.txt" */
2652 SetLastError( 0xdeadbeaf );
2653 strcpy(buffer2, nonexistent);
2654 strcat(buffer2, "\\bar.txt");
2655 handle = FindFirstFileA(buffer2, &data);
2656 err = GetLastError();
2657 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2658 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2659
2660 /* try FindFirstFileA on "C:\foo\*.*" */
2661 SetLastError( 0xdeadbeaf );
2662 strcpy(buffer2, nonexistent);
2663 strcat(buffer2, "\\*.*");
2664 handle = FindFirstFileA(buffer2, &data);
2665 err = GetLastError();
2666 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2667 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2668
2669 /* try FindFirstFileA on "foo\bar.txt" */
2670 SetLastError( 0xdeadbeaf );
2671 strcpy(buffer2, nonexistent + 3);
2672 strcat(buffer2, "\\bar.txt");
2673 handle = FindFirstFileA(buffer2, &data);
2674 err = GetLastError();
2675 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2676 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2677
2678 /* try FindFirstFileA on "c:\nul" */
2679 SetLastError( 0xdeadbeaf );
2680 strcpy(buffer2, buffer);
2681 strcat(buffer2, "nul");
2682 handle = FindFirstFileA(buffer2, &data);
2683 err = GetLastError();
2684 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2685 ok( 0 == lstrcmpiA(data.cFileName, "nul"), "wrong name %s\n", data.cFileName );
2686 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2687 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2688 "wrong attributes %x\n", data.dwFileAttributes );
2689 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2690 {
2691 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2692 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2693 }
2694 SetLastError( 0xdeadbeaf );
2695 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2696 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2697 ok( FindClose( handle ), "failed to close handle\n" );
2698
2699 /* try FindFirstFileA on "lpt1" */
2700 SetLastError( 0xdeadbeaf );
2701 strcpy(buffer2, "lpt1");
2702 handle = FindFirstFileA(buffer2, &data);
2703 err = GetLastError();
2704 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2705 ok( 0 == lstrcmpiA(data.cFileName, "lpt1"), "wrong name %s\n", data.cFileName );
2706 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2707 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2708 "wrong attributes %x\n", data.dwFileAttributes );
2709 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2710 {
2711 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2712 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2713 }
2714 SetLastError( 0xdeadbeaf );
2715 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2716 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2717 ok( FindClose( handle ), "failed to close handle\n" );
2718
2719 /* try FindFirstFileA on "c:\nul\*" */
2720 SetLastError( 0xdeadbeaf );
2721 strcpy(buffer2, buffer);
2722 strcat(buffer2, "nul\\*");
2723 handle = FindFirstFileA(buffer2, &data);
2724 err = GetLastError();
2725 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2726 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2727
2728 /* try FindFirstFileA on "c:\nul*" */
2729 SetLastError( 0xdeadbeaf );
2730 strcpy(buffer2, buffer);
2731 strcat(buffer2, "nul*");
2732 handle = FindFirstFileA(buffer2, &data);
2733 err = GetLastError();
2734 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2735 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2736
2737 /* try FindFirstFileA on "c:\foo\bar\nul" */
2738 SetLastError( 0xdeadbeaf );
2739 strcpy(buffer2, buffer);
2740 strcat(buffer2, "foo\\bar\\nul");
2741 handle = FindFirstFileA(buffer2, &data);
2742 err = GetLastError();
2743 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2744 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2745
2746 /* try FindFirstFileA on "c:\foo\nul\bar" */
2747 SetLastError( 0xdeadbeaf );
2748 strcpy(buffer2, buffer);
2749 strcat(buffer2, "foo\\nul\\bar");
2750 handle = FindFirstFileA(buffer2, &data);
2751 err = GetLastError();
2752 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2753 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2754
2755 /* try FindFirstFileA with invalid characters */
2756 CreateDirectoryA("test-dir", NULL);
2757 _lclose(_lcreat("test-file", 0));
2758
2759 for (i = 0; i < sizeof(invalid_char_tests) / sizeof(invalid_char_tests[0]); i++)
2760 {
2763 {
2764 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileA on %s should succeed\n",
2766 }
2767 else
2768 {
2769 ok(handle == INVALID_HANDLE_VALUE, "FindFirstFileA on %s should fail\n",
2771 }
2774 }
2775
2776 DeleteFileA("test-file");
2777 RemoveDirectoryA("test-dir");
2778}
2779
2780static void test_FindNextFileA(void)
2781{
2782 HANDLE handle;
2783 WIN32_FIND_DATAA search_results;
2784 int err;
2785 char buffer[5] = "C:\\*";
2786
2788 handle = FindFirstFileA(buffer,&search_results);
2789 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
2790 while (FindNextFileA(handle, &search_results))
2791 {
2792 /* get to the end of the files */
2793 }
2794 ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
2795 err = GetLastError();
2796 ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
2797}
2798
2800{
2801 WIN32_FIND_DATAA search_results;
2802 HANDLE handle;
2803 BOOL ret;
2804
2805 if (!pFindFirstFileExA)
2806 {
2807 win_skip("FindFirstFileExA() is missing\n");
2808 return;
2809 }
2810
2811 trace("Running FindFirstFileExA tests with level=%d, search_ops=%d, flags=%u\n",
2812 level, search_ops, flags);
2813
2814 CreateDirectoryA("test-dir", NULL);
2815 _lclose(_lcreat("test-dir\\file1", 0));
2816 _lclose(_lcreat("test-dir\\file2", 0));
2817 CreateDirectoryA("test-dir\\dir1", NULL);
2818 SetLastError(0xdeadbeef);
2819 handle = pFindFirstFileExA("test-dir\\*", level, &search_results, search_ops, NULL, flags);
2821 {
2822 win_skip("FindFirstFileExA is not implemented\n");
2823 goto cleanup;
2824 }
2826 {
2827 win_skip("FindFirstFileExA flag FIND_FIRST_EX_LARGE_FETCH not supported, skipping test\n");
2828 goto cleanup;
2829 }
2831 {
2832 win_skip("FindFirstFileExA level FindExInfoBasic not supported, skipping test\n");
2833 goto cleanup;
2834 }
2835
2836#define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
2837#define CHECK_LEVEL(fn) (level != FindExInfoBasic || !(fn)[0])
2838
2839 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFile failed (err=%u)\n", GetLastError());
2840 ok(strcmp(search_results.cFileName, ".") == 0, "First entry should be '.', is %s\n", search_results.cFileName);
2841 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2842
2843 ok(FindNextFileA(handle, &search_results), "Fetching second file failed\n");
2844 ok(strcmp(search_results.cFileName, "..") == 0, "Second entry should be '..' is %s\n", search_results.cFileName);
2845 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2846
2847 ok(FindNextFileA(handle, &search_results), "Fetching third file failed\n");
2848 ok(CHECK_NAME(search_results.cFileName), "Invalid third entry - %s\n", search_results.cFileName);
2849 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2850
2851 SetLastError(0xdeadbeef);
2852 ret = FindNextFileA(handle, &search_results);
2853 if (!ret && (GetLastError() == ERROR_NO_MORE_FILES) && (search_ops == FindExSearchLimitToDirectories))
2854 {
2855 skip("File system supports directory filtering\n");
2856 /* Results from the previous call are not cleared */
2857 ok(strcmp(search_results.cFileName, "dir1") == 0, "Third entry should be 'dir1' is %s\n", search_results.cFileName);
2858 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2859
2860 }
2861 else
2862 {
2863 ok(ret, "Fetching fourth file failed\n");
2864 ok(CHECK_NAME(search_results.cFileName), "Invalid fourth entry - %s\n", search_results.cFileName);
2865 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2866
2867 ok(FindNextFileA(handle, &search_results), "Fetching fifth file failed\n");
2868 ok(CHECK_NAME(search_results.cFileName), "Invalid fifth entry - %s\n", search_results.cFileName);
2869 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2870
2871 ok(FindNextFileA(handle, &search_results) == FALSE, "Fetching sixth file should fail\n");
2872 }
2873
2874#undef CHECK_NAME
2875#undef CHECK_LEVEL
2876
2877 FindClose( handle );
2878
2879 /* Most Windows systems seem to ignore the FIND_FIRST_EX_CASE_SENSITIVE flag. Unofficial documentation
2880 * suggests that there are registry keys and that it might depend on the used filesystem. */
2881 SetLastError(0xdeadbeef);
2882 handle = pFindFirstFileExA("TEST-DIR\\*", level, &search_results, search_ops, NULL, flags);
2884 {
2886 "Unexpected error %x, expected valid handle or ERROR_PATH_NOT_FOUND\n", GetLastError());
2887 trace("FindFirstFileExA flag FIND_FIRST_EX_CASE_SENSITIVE is %signored\n",
2888 (handle == INVALID_HANDLE_VALUE) ? "not " : "");
2889 }
2890 else
2891 ok(handle != INVALID_HANDLE_VALUE, "Unexpected error %x, expected valid handle\n", GetLastError());
2893 FindClose( handle );
2894
2895cleanup:
2896 DeleteFileA("test-dir\\file1");
2897 DeleteFileA("test-dir\\file2");
2898 RemoveDirectoryA("test-dir\\dir1");
2899 RemoveDirectoryA("test-dir");
2900}
2901
2903{
2905 HANDLE handle;
2906 int i;
2907 static const char* files[] = {
2908 "..a", "..a.a", ".a", ".a..a", ".a.a", ".aaa",
2909 "a", "a..a", "a.a", "a.a.a", "aa", "aaa", "aaaa"
2910 };
2911 static const struct {
2912 int todo;
2913 const char *pattern, *result;
2914 } tests[] = {
2915 {0, "*.*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2916 {0, "*.*.", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2917 {0, ".*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa'"},
2918 {0, "*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2919 {0, ".*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa'"},
2920 {1, "*.", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2921 {0, "*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2922 {1, "*..*", ", '.', '..', '..a', '..a.a', '.a..a', 'a..a'"},
2923 {1, "*..", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2924 {1, ".*.", ", '.', '..', '.a', '.aaa'"},
2925 {0, "..*", ", '.', '..', '..a', '..a.a'"},
2926 {0, "**", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2927 {0, "**.", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2928 {0, "*. ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2929 {1, "* .", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2930 {0, "* . ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2931 {0, "*.. ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2932 {1, "*. .", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2933 {1, "* ..", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2934 {1, " *..", ", '.aaa'"