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