git.oblomov.eu Git - wine/blob - dlls/kernel32/tests/file.c

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