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