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