dlls/kernel32/tests/file.c

   1 /*
   2  * Unit tests for file functions in Wine
   3  *
   4  * Copyright (c) 2002, 2004 Jakob Eriksson
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25
  26 #include "wine/test.h"
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30
  31 /* keep filename and filenameW the same */
  32 static const char filename[] = "testfile.xxx";
  33 static const WCHAR filenameW[] = { 't','e','s','t','f','i','l','e','.','x','x','x',0 };
  34 static const char sillytext[] =
  35 "en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
  36 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  37 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  38 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  39 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  40 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  41 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  42 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  43 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  44 "sdlkfjasdlkfj a dslkj adsklf  \n  \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
  45
  46
  47 static void test__hread( void )
  48 {
  49     HFILE filehandle;
  50     char buffer[10000];
  51     long bytes_read;
  52     long bytes_wanted;
  53     long i;
  54     BOOL ret;
  55
  56     SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
  57     DeleteFileA( filename );
  58     filehandle = _lcreat( filename, 0 );
  59     if (filehandle == HFILE_ERROR)
  60     {
  61         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
  62         return;
  63     }
  64
  65     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
  66
  67     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
  68
  69     filehandle = _lopen( filename, OF_READ );
  70
  71     ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError(  ) );
  72
  73     bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
  74
  75     ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
  76
  77     for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
  78     {
  79         ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
  80         ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
  81         for (i = 0; i < bytes_wanted; i++)
  82         {
  83             ok( buffer[i] == sillytext[i], "that's not what's written\n" );
  84         }
  85     }
  86
  87     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
  88
  89     ret = DeleteFileA( filename );
  90     ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError(  ) );
  91 }
  92
  93
  94 static void test__hwrite( void )
  95 {
  96     HFILE filehandle;
  97     char buffer[10000];
  98     long bytes_read;
  99     long bytes_written;
 100     long blocks;
 101     long i;
 102     char *contents;
 103     HLOCAL memory_object;
 104     char checksum[1];
 105     BOOL ret;
 106
 107     filehandle = _lcreat( filename, 0 );
 108     if (filehandle == HFILE_ERROR)
 109     {
 110         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 111         return;
 112     }
 113
 114     ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
 115
 116     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 117
 118     filehandle = _lopen( filename, OF_READ );
 119
 120     bytes_read = _hread( filehandle, buffer, 1);
 121
 122     ok( 0 == bytes_read, "file read size error\n" );
 123
 124     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 125
 126     filehandle = _lopen( filename, OF_READWRITE );
 127
 128     bytes_written = 0;
 129     checksum[0] = '\0';
 130     srand( (unsigned)time( NULL ) );
 131     for (blocks = 0; blocks < 100; blocks++)
 132     {
 133         for (i = 0; i < (long)sizeof( buffer ); i++)
 134         {
 135             buffer[i] = rand(  );
 136             checksum[0] = checksum[0] + buffer[i];
 137         }
 138         ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
 139         bytes_written = bytes_written + sizeof( buffer );
 140     }
 141
 142     ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
 143     bytes_written++;
 144
 145     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 146
 147     memory_object = LocalAlloc( LPTR, bytes_written );
 148
 149     ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
 150
 151     contents = LocalLock( memory_object );
 152
 153     filehandle = _lopen( filename, OF_READ );
 154
 155     contents = LocalLock( memory_object );
 156
 157     ok( NULL != contents, "LocalLock whines\n" );
 158
 159     ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
 160
 161     checksum[0] = '\0';
 162     i = 0;
 163     do
 164     {
 165         checksum[0] = checksum[0] + contents[i];
 166         i++;
 167     }
 168     while (i < bytes_written - 1);
 169
 170     ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
 171
 172     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 173
 174     ret = DeleteFileA( filename );
 175     ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError(  ) );
 176 }
 177
 178
 179 static void test__lclose( void )
 180 {
 181     HFILE filehandle;
 182     BOOL ret;
 183
 184     filehandle = _lcreat( filename, 0 );
 185     if (filehandle == HFILE_ERROR)
 186     {
 187         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 188         return;
 189     }
 190
 191     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 192
 193     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 194
 195     ret = DeleteFileA( filename );
 196     ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError(  ) );
 197 }
 198
 199
 200 static void test__lcreat( void )
 201 {
 202     HFILE filehandle;
 203     char buffer[10000];
 204     WIN32_FIND_DATAA search_results;
 205     char slashname[] = "testfi/";
 206     int err;
 207     HANDLE find;
 208     BOOL ret;
 209
 210     filehandle = _lcreat( filename, 0 );
 211     if (filehandle == HFILE_ERROR)
 212     {
 213         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 214         return;
 215     }
 216
 217     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 218
 219     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 220
 221     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 222
 223     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 224
 225     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should be able to find file\n" );
 226
 227     ret = DeleteFileA(filename);
 228     ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError());
 229
 230     filehandle = _lcreat( filename, 1 ); /* readonly */
 231     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError(  ) );
 232
 233     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
 234
 235     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 236
 237     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should be able to find file\n" );
 238
 239     ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
 240
 241     ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
 242
 243     ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
 244
 245     filehandle = _lcreat( filename, 2 );
 246     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError(  ) );
 247
 248     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 249
 250     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 251
 252     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 253
 254     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 255
 256     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should STILL be able to find file\n" );
 257
 258     ret = DeleteFileA( filename );
 259     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 260
 261     filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
 262     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError(  ) );
 263
 264     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 265
 266     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 267
 268     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 269
 270     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 271
 272     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should STILL be able to find file\n" );
 273
 274     ret = DeleteFileA( filename );
 275     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 276
 277     filehandle=_lcreat (slashname, 0); /* illegal name */
 278     if (HFILE_ERROR==filehandle) {
 279       err=GetLastError ();
 280       ok (err==ERROR_INVALID_NAME || err==ERROR_PATH_NOT_FOUND,
 281           "creating file \"%s\" failed with error %d\n", slashname, err);
 282     } else { /* only NT succeeds */
 283       _lclose(filehandle);
 284       find=FindFirstFileA (slashname, &search_results);
 285       if (INVALID_HANDLE_VALUE!=find)
 286       {
 287         ret = FindClose (find);
 288         ok (0 != ret, "FindClose complains (%d)\n", GetLastError ());
 289         slashname[strlen(slashname)-1]=0;
 290         ok (!strcmp (slashname, search_results.cFileName),
 291             "found unexpected name \"%s\"\n", search_results.cFileName);
 292         ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
 293             "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
 294             search_results.dwFileAttributes);
 295       }
 296     ret = DeleteFileA( slashname );
 297     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 298     }
 299
 300     filehandle=_lcreat (filename, 8); /* illegal attribute */
 301     if (HFILE_ERROR==filehandle)
 302       ok (0, "couldn't create volume label \"%s\"\n", filename);
 303     else {
 304       _lclose(filehandle);
 305       find=FindFirstFileA (filename, &search_results);
 306       if (INVALID_HANDLE_VALUE==find)
 307         ok (0, "file \"%s\" not found\n", filename);
 308       else {
 309         ret = FindClose(find);
 310         ok ( 0 != ret, "FindClose complains (%d)\n", GetLastError ());
 311         ok (!strcmp (filename, search_results.cFileName),
 312             "found unexpected name \"%s\"\n", search_results.cFileName);
 313         search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
 314         ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
 315             "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
 316             search_results.dwFileAttributes);
 317       }
 318     ret = DeleteFileA( filename );
 319     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 320     }
 321 }
 322
 323
 324 static void test__llseek( void )
 325 {
 326     INT i;
 327     HFILE filehandle;
 328     char buffer[1];
 329     long bytes_read;
 330     BOOL ret;
 331
 332     filehandle = _lcreat( filename, 0 );
 333     if (filehandle == HFILE_ERROR)
 334     {
 335         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 336         return;
 337     }
 338
 339     for (i = 0; i < 400; i++)
 340     {
 341         ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 342     }
 343     ok( HFILE_ERROR != _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ), "should be able to seek\n" );
 344     ok( HFILE_ERROR != _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ), "should be able to seek\n" );
 345
 346     bytes_read = _hread( filehandle, buffer, 1);
 347     ok( 1 == bytes_read, "file read size error\n" );
 348     ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
 349     ok( HFILE_ERROR != _llseek( filehandle, -400 * strlen( sillytext ), FILE_END ), "should be able to seek\n" );
 350
 351     bytes_read = _hread( filehandle, buffer, 1);
 352     ok( 1 == bytes_read, "file read size error\n" );
 353     ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
 354     ok( HFILE_ERROR != _llseek( filehandle, 1000000, FILE_END ), "should be able to seek past file; poor, poor Windows programmers\n" );
 355     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 356
 357     ret = DeleteFileA( filename );
 358     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 359 }
 360
 361
 362 static void test__llopen( void )
 363 {
 364     HFILE filehandle;
 365     UINT bytes_read;
 366     char buffer[10000];
 367     BOOL ret;
 368
 369     filehandle = _lcreat( filename, 0 );
 370     if (filehandle == HFILE_ERROR)
 371     {
 372         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 373         return;
 374     }
 375
 376     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 377     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 378
 379     filehandle = _lopen( filename, OF_READ );
 380     ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
 381     bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
 382     ok( strlen( sillytext )  == bytes_read, "file read size error\n" );
 383     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 384
 385     filehandle = _lopen( filename, OF_READWRITE );
 386     bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
 387     ok( strlen( sillytext )  == bytes_read, "file read size error\n" );
 388     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
 389     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 390
 391     filehandle = _lopen( filename, OF_WRITE );
 392     ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
 393     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
 394     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 395
 396     ret = DeleteFileA( filename );
 397     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 398     /* TODO - add tests for the SHARE modes  -  use two processes to pull this one off */
 399 }
 400
 401
 402 static void test__lread( void )
 403 {
 404     HFILE filehandle;
 405     char buffer[10000];
 406     long bytes_read;
 407     UINT bytes_wanted;
 408     UINT i;
 409     BOOL ret;
 410
 411     filehandle = _lcreat( filename, 0 );
 412     if (filehandle == HFILE_ERROR)
 413     {
 414         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 415         return;
 416     }
 417
 418     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 419
 420     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 421
 422     filehandle = _lopen( filename, OF_READ );
 423
 424     ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError());
 425
 426     bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
 427
 428     ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
 429
 430     for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
 431     {
 432         ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 433         ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
 434         for (i = 0; i < bytes_wanted; i++)
 435         {
 436             ok( buffer[i] == sillytext[i], "that's not what's written\n" );
 437         }
 438     }
 439
 440     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 441
 442     ret = DeleteFileA( filename );
 443     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 444 }
 445
 446
 447 static void test__lwrite( void )
 448 {
 449     HFILE filehandle;
 450     char buffer[10000];
 451     long bytes_read;
 452     long bytes_written;
 453     long blocks;
 454     long i;
 455     char *contents;
 456     HLOCAL memory_object;
 457     char checksum[1];
 458     BOOL ret;
 459
 460     filehandle = _lcreat( filename, 0 );
 461     if (filehandle == HFILE_ERROR)
 462     {
 463         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
 464         return;
 465     }
 466
 467     ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
 468
 469     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 470
 471     filehandle = _lopen( filename, OF_READ );
 472
 473     bytes_read = _hread( filehandle, buffer, 1);
 474
 475     ok( 0 == bytes_read, "file read size error\n" );
 476
 477     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 478
 479     filehandle = _lopen( filename, OF_READWRITE );
 480
 481     bytes_written = 0;
 482     checksum[0] = '\0';
 483     srand( (unsigned)time( NULL ) );
 484     for (blocks = 0; blocks < 100; blocks++)
 485     {
 486         for (i = 0; i < (long)sizeof( buffer ); i++)
 487         {
 488             buffer[i] = rand(  );
 489             checksum[0] = checksum[0] + buffer[i];
 490         }
 491         ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
 492         bytes_written = bytes_written + sizeof( buffer );
 493     }
 494
 495     ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
 496     bytes_written++;
 497
 498     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 499
 500     memory_object = LocalAlloc( LPTR, bytes_written );
 501
 502     ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
 503
 504     contents = LocalLock( memory_object );
 505
 506     filehandle = _lopen( filename, OF_READ );
 507
 508     contents = LocalLock( memory_object );
 509
 510     ok( NULL != contents, "LocalLock whines\n" );
 511
 512     ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
 513
 514     checksum[0] = '\0';
 515     i = 0;
 516     do
 517     {
 518         checksum[0] += contents[i];
 519         i++;
 520     }
 521     while (i < bytes_written - 1);
 522
 523     ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
 524
 525     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 526
 527     ret = DeleteFileA( filename );
 528     ok( ret, "DeleteFile failed (%d)\n", GetLastError(  ) );
 529 }
 530
 531 static void test_CopyFileA(void)
 532 {
 533     char temp_path[MAX_PATH];
 534     char source[MAX_PATH], dest[MAX_PATH];
 535     static const char prefix[] = "pfx";
 536     HANDLE hfile;
 537     FILETIME ft1, ft2;
 538     char buf[10];
 539     DWORD ret;
 540     BOOL retok;
 541
 542     ret = GetTempPathA(MAX_PATH, temp_path);
 543     ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
 544     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 545
 546     ret = GetTempFileNameA(temp_path, prefix, 0, source);
 547     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
 548
 549     /* make the source have not zero size */
 550     hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
 551     ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
 552     retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
 553     ok( retok && ret == sizeof(prefix),
 554        "WriteFile error %d\n", GetLastError());
 555     ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
 556     /* get the file time and change it to prove the difference */
 557     ret = GetFileTime(hfile, NULL, NULL, &ft1);
 558     ok( ret, "GetFileTime error %d\n", GetLastError());
 559     ft1.dwLowDateTime -= 600000000; /* 60 second */
 560     ret = SetFileTime(hfile, NULL, NULL, &ft1);
 561     ok( ret, "SetFileTime error %d\n", GetLastError());
 562     GetFileTime(hfile, NULL, NULL, &ft1);  /* get the actual time back */
 563     CloseHandle(hfile);
 564
 565     ret = GetTempFileNameA(temp_path, prefix, 0, dest);
 566     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
 567
 568     SetLastError(0xdeadbeef);
 569     ret = CopyFileA(source, dest, TRUE);
 570     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
 571        "CopyFileA: unexpected error %d\n", GetLastError());
 572
 573     ret = CopyFileA(source, dest, FALSE);
 574     ok(ret, "CopyFileA: error %d\n", GetLastError());
 575
 576     /* make sure that destination has correct size */
 577     hfile = CreateFileA(dest, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 578     ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
 579     ret = GetFileSize(hfile, NULL);
 580     ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
 581
 582     /* make sure that destination has the same filetime */
 583     ret = GetFileTime(hfile, NULL, NULL, &ft2);
 584     ok( ret, "GetFileTime error %d\n", GetLastError());
 585     ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
 586
 587     SetLastError(0xdeadbeef);
 588     ret = CopyFileA(source, dest, FALSE);
 589     ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION,
 590        "CopyFileA: ret = %d, unexpected error %d\n", ret, GetLastError());
 591
 592     /* make sure that destination still has correct size */
 593     ret = GetFileSize(hfile, NULL);
 594     ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
 595     retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
 596     ok( retok && ret == sizeof(prefix),
 597        "ReadFile: error %d\n", GetLastError());
 598     ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
 599     CloseHandle(hfile);
 600
 601     ret = DeleteFileA(source);
 602     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 603     ret = DeleteFileA(dest);
 604     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 605 }
 606
 607 static void test_CopyFileW(void)
 608 {
 609     WCHAR temp_path[MAX_PATH];
 610     WCHAR source[MAX_PATH], dest[MAX_PATH];
 611     static const WCHAR prefix[] = {'p','f','x',0};
 612     DWORD ret;
 613
 614     ret = GetTempPathW(MAX_PATH, temp_path);
 615     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 616         return;
 617     ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
 618     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 619
 620     ret = GetTempFileNameW(temp_path, prefix, 0, source);
 621     ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
 622
 623     ret = GetTempFileNameW(temp_path, prefix, 0, dest);
 624     ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
 625
 626     ret = CopyFileW(source, dest, TRUE);
 627     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
 628        "CopyFileW: unexpected error %d\n", GetLastError());
 629
 630     ret = CopyFileW(source, dest, FALSE);
 631     ok(ret, "CopyFileW: error %d\n", GetLastError());
 632
 633     ret = DeleteFileW(source);
 634     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 635     ret = DeleteFileW(dest);
 636     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 637 }
 638
 639 static void test_CreateFileA(void)
 640 {
 641     HANDLE hFile;
 642     char temp_path[MAX_PATH];
 643     char filename[MAX_PATH];
 644     static const char prefix[] = "pfx";
 645     DWORD ret;
 646
 647     ret = GetTempPathA(MAX_PATH, temp_path);
 648     ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
 649     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 650
 651     ret = GetTempFileNameA(temp_path, prefix, 0, filename);
 652     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
 653
 654     SetLastError(0xdeadbeef);
 655     hFile = CreateFileA(filename, GENERIC_READ, 0, NULL,
 656                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 657     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
 658         "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
 659
 660     SetLastError(0xdeadbeef);
 661     hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 662                         CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 663     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
 664        "hFile %p, last error %u\n", hFile, GetLastError());
 665
 666     CloseHandle(hFile);
 667
 668     SetLastError(0xdeadbeef);
 669     hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 670                         OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 671     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
 672        "hFile %p, last error %u\n", hFile, GetLastError());
 673
 674     CloseHandle(hFile);
 675
 676     ret = DeleteFileA(filename);
 677     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 678
 679     SetLastError(0xdeadbeef);
 680     hFile = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 681                         OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 682     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == 0,
 683        "hFile %p, last error %u\n", hFile, GetLastError());
 684
 685     CloseHandle(hFile);
 686
 687     ret = DeleteFileA(filename);
 688     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 689 }
 690
 691 static void test_CreateFileW(void)
 692 {
 693     HANDLE hFile;
 694     WCHAR temp_path[MAX_PATH];
 695     WCHAR filename[MAX_PATH];
 696     static const WCHAR emptyW[]={'\0'};
 697     static const WCHAR prefix[] = {'p','f','x',0};
 698     static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
 699     DWORD ret;
 700
 701     ret = GetTempPathW(MAX_PATH, temp_path);
 702     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 703         return;
 704     ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
 705     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 706
 707     ret = GetTempFileNameW(temp_path, prefix, 0, filename);
 708     ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
 709
 710     SetLastError(0xdeadbeef);
 711     hFile = CreateFileW(filename, GENERIC_READ, 0, NULL,
 712                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 713     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
 714         "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
 715
 716     SetLastError(0xdeadbeef);
 717     hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 718                         CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 719     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
 720        "hFile %p, last error %u\n", hFile, GetLastError());
 721
 722     CloseHandle(hFile);
 723
 724     SetLastError(0xdeadbeef);
 725     hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 726                         OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 727     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == ERROR_ALREADY_EXISTS,
 728        "hFile %p, last error %u\n", hFile, GetLastError());
 729
 730     CloseHandle(hFile);
 731
 732     ret = DeleteFileW(filename);
 733     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 734
 735     SetLastError(0xdeadbeef);
 736     hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
 737                         OPEN_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
 738     ok(hFile != INVALID_HANDLE_VALUE && GetLastError() == 0,
 739        "hFile %p, last error %u\n", hFile, GetLastError());
 740
 741     CloseHandle(hFile);
 742
 743     ret = DeleteFileW(filename);
 744     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 745
 746     if (0)
 747     {
 748         /* this crashes on NT4.0 */
 749         hFile = CreateFileW(NULL, GENERIC_READ, 0, NULL,
 750                             CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 751         ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
 752            "CreateFileW(NULL) returned ret=%p error=%u\n",hFile,GetLastError());
 753     }
 754
 755     hFile = CreateFileW(emptyW, GENERIC_READ, 0, NULL,
 756                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 757     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
 758        "CreateFileW(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
 759
 760     /* test the result of opening a nonexistent driver name */
 761     hFile = CreateFileW(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 762                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 763     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND,
 764        "CreateFileW on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
 765 }
 766
 767 static void test_GetTempFileNameA(void)
 768 {
 769     UINT result;
 770     char out[MAX_PATH];
 771     char expected[MAX_PATH + 10];
 772     char windowsdir[MAX_PATH + 10];
 773     char windowsdrive[3];
 774
 775     result = GetWindowsDirectory(windowsdir, sizeof(windowsdir));
 776     ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
 777     ok(result != 0, "GetWindowsDirectory: error %d\n", GetLastError());
 778
 779     /* If the Windows directory is the root directory, it ends in backslash, not else. */
 780     if (strlen(windowsdir) != 3) /* As in  "C:\"  or  "F:\"  */
 781     {
 782         strcat(windowsdir, "\\");
 783     }
 784
 785     windowsdrive[0] = windowsdir[0];
 786     windowsdrive[1] = windowsdir[1];
 787     windowsdrive[2] = '\0';
 788
 789     result = GetTempFileNameA(windowsdrive, "abc", 1, out);
 790     ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
 791     ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
 792        "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
 793        windowsdrive[0], out);
 794
 795     result = GetTempFileNameA(windowsdir, "abc", 2, out);
 796     ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
 797     expected[0] = '\0';
 798     strcat(expected, windowsdir);
 799     strcat(expected, "abc2.tmp");
 800     ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
 801        out, expected);
 802 }
 803
 804 static void test_DeleteFileA( void )
 805 {
 806     BOOL ret;
 807
 808     ret = DeleteFileA(NULL);
 809     ok(!ret && (GetLastError() == ERROR_INVALID_PARAMETER ||
 810                 GetLastError() == ERROR_PATH_NOT_FOUND),
 811        "DeleteFileA(NULL) returned ret=%d error=%d\n",ret,GetLastError());
 812
 813     ret = DeleteFileA("");
 814     ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND ||
 815                 GetLastError() == ERROR_BAD_PATHNAME),
 816        "DeleteFileA(\"\") returned ret=%d error=%d\n",ret,GetLastError());
 817
 818     ret = DeleteFileA("nul");
 819     ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
 820                 GetLastError() == ERROR_INVALID_PARAMETER ||
 821                 GetLastError() == ERROR_ACCESS_DENIED ||
 822                 GetLastError() == ERROR_INVALID_FUNCTION),
 823        "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret,GetLastError());
 824 }
 825
 826 static void test_DeleteFileW( void )
 827 {
 828     BOOL ret;
 829     static const WCHAR emptyW[]={'\0'};
 830
 831     ret = DeleteFileW(NULL);
 832     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 833         return;
 834     ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
 835        "DeleteFileW(NULL) returned ret=%d error=%d\n",ret,GetLastError());
 836
 837     ret = DeleteFileW(emptyW);
 838     ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
 839        "DeleteFileW(\"\") returned ret=%d error=%d\n",ret,GetLastError());
 840 }
 841
 842 #define IsDotDir(x)     ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
 843
 844 static void test_MoveFileA(void)
 845 {
 846     char tempdir[MAX_PATH];
 847     char source[MAX_PATH], dest[MAX_PATH];
 848     static const char prefix[] = "pfx";
 849     DWORD ret;
 850
 851     ret = GetTempPathA(MAX_PATH, tempdir);
 852     ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
 853     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 854
 855     ret = GetTempFileNameA(tempdir, prefix, 0, source);
 856     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
 857
 858     ret = GetTempFileNameA(tempdir, prefix, 0, dest);
 859     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
 860
 861     ret = MoveFileA(source, dest);
 862     ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
 863        "MoveFileA: unexpected error %d\n", GetLastError());
 864
 865     ret = DeleteFileA(dest);
 866     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 867
 868     ret = MoveFileA(source, dest);
 869     ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
 870
 871     lstrcatA(tempdir, "Remove Me");
 872     ret = CreateDirectoryA(tempdir, NULL);
 873     ok(ret == TRUE, "CreateDirectoryA failed\n");
 874
 875     lstrcpyA(source, dest);
 876     lstrcpyA(dest, tempdir);
 877     lstrcatA(dest, "\\wild?.*");
 878     /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
 879     ret = MoveFileA(source, dest);
 880     ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
 881     ok(GetLastError() == ERROR_INVALID_NAME || /* NT */
 882        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x */
 883        "MoveFileA: with wildcards, unexpected error %d\n", GetLastError());
 884     if (ret || (GetLastError() != ERROR_INVALID_NAME))
 885     {
 886         WIN32_FIND_DATAA fd;
 887         char temppath[MAX_PATH];
 888         HANDLE hFind;
 889
 890         lstrcpyA(temppath, tempdir);
 891         lstrcatA(temppath, "\\*.*");
 892         hFind = FindFirstFileA(temppath, &fd);
 893         if (INVALID_HANDLE_VALUE != hFind)
 894         {
 895           LPSTR lpName;
 896           do
 897           {
 898             lpName = fd.cAlternateFileName;
 899             if (!lpName[0])
 900               lpName = fd.cFileName;
 901             ok(IsDotDir(lpName), "MoveFileA: wildcards file created!\n");
 902           }
 903           while (FindNextFileA(hFind, &fd));
 904           FindClose(hFind);
 905         }
 906     }
 907     ret = DeleteFileA(source);
 908     ok(ret, "DeleteFileA: error %d\n", GetLastError());
 909     ret = DeleteFileA(dest);
 910     ok(!ret, "DeleteFileA: error %d\n", GetLastError());
 911     ret = RemoveDirectoryA(tempdir);
 912     ok(ret, "DeleteDirectoryA: error %d\n", GetLastError());
 913 }
 914
 915 static void test_MoveFileW(void)
 916 {
 917     WCHAR temp_path[MAX_PATH];
 918     WCHAR source[MAX_PATH], dest[MAX_PATH];
 919     static const WCHAR prefix[] = {'p','f','x',0};
 920     DWORD ret;
 921
 922     ret = GetTempPathW(MAX_PATH, temp_path);
 923     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 924         return;
 925     ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
 926     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 927
 928     ret = GetTempFileNameW(temp_path, prefix, 0, source);
 929     ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
 930
 931     ret = GetTempFileNameW(temp_path, prefix, 0, dest);
 932     ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
 933
 934     ret = MoveFileW(source, dest);
 935     ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
 936        "CopyFileW: unexpected error %d\n", GetLastError());
 937
 938     ret = DeleteFileW(source);
 939     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 940     ret = DeleteFileW(dest);
 941     ok(ret, "DeleteFileW: error %d\n", GetLastError());
 942 }
 943
 944 #define PATTERN_OFFSET 0x10
 945
 946 static void test_offset_in_overlapped_structure(void)
 947 {
 948     HANDLE hFile;
 949     OVERLAPPED ov;
 950     DWORD done, offset;
 951     BOOL rc;
 952     BYTE buf[256], pattern[] = "TeSt";
 953     UINT i;
 954     char temp_path[MAX_PATH], temp_fname[MAX_PATH];
 955     BOOL ret;
 956
 957     ret =GetTempPathA(MAX_PATH, temp_path);
 958     ok( ret, "GetTempPathA error %d\n", GetLastError());
 959     ret =GetTempFileNameA(temp_path, "pfx", 0, temp_fname);
 960     ok( ret, "GetTempFileNameA error %d\n", GetLastError());
 961
 962     /*** Write File *****************************************************/
 963
 964     hFile = CreateFileA(temp_fname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 965     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
 966
 967     for(i = 0; i < sizeof(buf); i++) buf[i] = i;
 968     ret = WriteFile(hFile, buf, sizeof(buf), &done, NULL);
 969     ok( ret, "WriteFile error %d\n", GetLastError());
 970     ok(done == sizeof(buf), "expected number of bytes written %u\n", done);
 971
 972     memset(&ov, 0, sizeof(ov));
 973     S(U(ov)).Offset = PATTERN_OFFSET;
 974     S(U(ov)).OffsetHigh = 0;
 975     rc=WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
 976     /* Win 9x does not support the overlapped I/O on files */
 977     if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
 978         ok(rc, "WriteFile error %d\n", GetLastError());
 979         ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
 980         offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
 981         ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
 982
 983         S(U(ov)).Offset = sizeof(buf) * 2;
 984         S(U(ov)).OffsetHigh = 0;
 985         ret = WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
 986         ok( ret, "WriteFile error %d\n", GetLastError());
 987         ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
 988         offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
 989         ok(offset == sizeof(buf) * 2 + sizeof(pattern), "wrong file offset %d\n", offset);
 990     }
 991
 992     CloseHandle(hFile);
 993
 994     /*** Read File *****************************************************/
 995
 996     hFile = CreateFileA(temp_fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
 997     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
 998
 999     memset(buf, 0, sizeof(buf));
1000     memset(&ov, 0, sizeof(ov));
1001     S(U(ov)).Offset = PATTERN_OFFSET;
1002     S(U(ov)).OffsetHigh = 0;
1003     rc=ReadFile(hFile, buf, sizeof(pattern), &done, &ov);
1004     /* Win 9x does not support the overlapped I/O on files */
1005     if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
1006         ok(rc, "ReadFile error %d\n", GetLastError());
1007         ok(done == sizeof(pattern), "expected number of bytes read %u\n", done);
1008         offset = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
1009         ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
1010         ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
1011     }
1012
1013     CloseHandle(hFile);
1014
1015     ret = DeleteFileA(temp_fname);
1016     ok( ret, "DeleteFileA error %d\n", GetLastError());
1017 }
1018
1019 static void test_LockFile(void)
1020 {
1021     HANDLE handle;
1022     DWORD written;
1023     OVERLAPPED overlapped;
1024     int limited_LockFile;
1025     int limited_UnLockFile;
1026
1027     handle = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
1028                           FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1029                           CREATE_ALWAYS, 0, 0 );
1030     if (handle == INVALID_HANDLE_VALUE)
1031     {
1032         ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1033         return;
1034     }
1035     ok( WriteFile( handle, sillytext, strlen(sillytext), &written, NULL ), "write failed\n" );
1036
1037     ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
1038     ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
1039
1040     limited_UnLockFile = 0;
1041     if (UnlockFile( handle, 0, 0, 0, 0 ))
1042     {
1043         limited_UnLockFile = 1;
1044     }
1045
1046     ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
1047     /* overlapping locks must fail */
1048     ok( !LockFile( handle, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
1049     ok( !LockFile( handle, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
1050     /* non-overlapping locks must succeed */
1051     ok( LockFile( handle, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
1052
1053     ok( !UnlockFile( handle, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
1054     ok( UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
1055     ok( !UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
1056     ok( UnlockFile( handle, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
1057
1058     S(U(overlapped)).Offset = 100;
1059     S(U(overlapped)).OffsetHigh = 0;
1060     overlapped.hEvent = 0;
1061
1062     /* Test for broken LockFileEx a la Windows 95 OSR2. */
1063     if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
1064     {
1065         /* LockFileEx is probably OK, test it more. */
1066         ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
1067             "LockFileEx 100,100 failed\n" );
1068     }
1069
1070     /* overlapping shared locks are OK */
1071     S(U(overlapped)).Offset = 150;
1072     limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
1073
1074     /* but exclusive is not */
1075     ok( !LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
1076                      0, 50, 0, &overlapped ),
1077         "LockFileEx exclusive 150,50 succeeded\n" );
1078     if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
1079     { /* UnLockFile is capable. */
1080         S(U(overlapped)).Offset = 100;
1081         ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
1082             "UnlockFileEx 150,100 again succeeded\n" );
1083     }
1084
1085     ok( LockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "LockFile failed\n" );
1086     ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
1087     ok( !LockFile( handle, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
1088     ok( UnlockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
1089
1090     /* wrap-around lock should not do anything */
1091     /* (but still succeeds on NT4 so we don't check result) */
1092     LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
1093
1094     limited_LockFile = 0;
1095     if (!LockFile( handle, ~0, ~0, 1, 0 ))
1096     {
1097         limited_LockFile = 1;
1098     }
1099
1100     limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
1101
1102     /* zero-byte lock */
1103     ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
1104     limited_LockFile || ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
1105     ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
1106     limited_LockFile || ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
1107
1108     ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
1109     !ok( UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 failed\n" );
1110
1111     ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
1112
1113     CloseHandle( handle );
1114     DeleteFileA( filename );
1115 }
1116
1117 static inline int is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2, BOOL is_win9x )
1118 {
1119     if (!is_win9x)
1120     {
1121         if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1122         if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
1123     }
1124     else
1125     {
1126         access1 &= ~DELETE;
1127         if (!access1) access1 = GENERIC_READ;
1128
1129         access2 &= ~DELETE;
1130         if (!access2) access2 = GENERIC_READ;
1131     }
1132
1133     if ((access1 & GENERIC_READ) && !(sharing2 & FILE_SHARE_READ)) return 0;
1134     if ((access1 & GENERIC_WRITE) && !(sharing2 & FILE_SHARE_WRITE)) return 0;
1135     if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return 0;
1136     if ((access2 & GENERIC_READ) && !(sharing1 & FILE_SHARE_READ)) return 0;
1137     if ((access2 & GENERIC_WRITE) && !(sharing1 & FILE_SHARE_WRITE)) return 0;
1138     if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return 0;
1139     return 1;
1140 }
1141
1142 static void test_file_sharing(void)
1143 {
1144     static const DWORD access_modes[] =
1145         { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ|GENERIC_WRITE,
1146           DELETE, GENERIC_READ|DELETE, GENERIC_WRITE|DELETE, GENERIC_READ|GENERIC_WRITE|DELETE };
1147     static const DWORD sharing_modes[] =
1148         { 0, FILE_SHARE_READ,
1149           FILE_SHARE_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1150           FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_DELETE,
1151           FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE };
1152     int a1, s1, a2, s2;
1153     int ret;
1154     HANDLE h, h2;
1155     BOOL is_win9x = FALSE;
1156
1157     /* make sure the file exists */
1158     h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1159     if (h == INVALID_HANDLE_VALUE)
1160     {
1161         ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
1162         return;
1163     }
1164     is_win9x = GetFileAttributesW(filenameW) == INVALID_FILE_ATTRIBUTES;
1165     CloseHandle( h );
1166
1167     for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
1168     {
1169         for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
1170         {
1171             /* Win9x doesn't support FILE_SHARE_DELETE */
1172             if (is_win9x && (sharing_modes[s1] & FILE_SHARE_DELETE))
1173                 continue;
1174
1175             SetLastError(0xdeadbeef);
1176             h = CreateFileA( filename, access_modes[a1], sharing_modes[s1],
1177                              NULL, OPEN_EXISTING, 0, 0 );
1178             if (h == INVALID_HANDLE_VALUE)
1179             {
1180                 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
1181                 return;
1182             }
1183             for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1184             {
1185                 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1186                 {
1187                     /* Win9x doesn't support FILE_SHARE_DELETE */
1188                     if (is_win9x && (sharing_modes[s2] & FILE_SHARE_DELETE))
1189                         continue;
1190
1191                     SetLastError(0xdeadbeef);
1192                     h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1193                                       NULL, OPEN_EXISTING, 0, 0 );
1194
1195                     if (is_sharing_compatible( access_modes[a1], sharing_modes[s1],
1196                                                access_modes[a2], sharing_modes[s2], is_win9x ))
1197                     {
1198                         ret = GetLastError();
1199
1200                         ok( h2 != INVALID_HANDLE_VALUE,
1201                             "open failed for modes %x/%x/%x/%x\n",
1202                             access_modes[a1], sharing_modes[s1],
1203                             access_modes[a2], sharing_modes[s2] );
1204                         ok( ret == 0xdeadbeef /* Win9x */ ||
1205                             ret == 0, /* XP */
1206                              "wrong error code %d\n", ret );
1207
1208                         CloseHandle( h2 );
1209                     }
1210                     else
1211                     {
1212                         ret = GetLastError();
1213
1214                         ok( h2 == INVALID_HANDLE_VALUE,
1215                             "open succeeded for modes %x/%x/%x/%x\n",
1216                             access_modes[a1], sharing_modes[s1],
1217                             access_modes[a2], sharing_modes[s2] );
1218                          ok( ret == ERROR_SHARING_VIOLATION,
1219                              "wrong error code %d\n", ret );
1220                     }
1221                 }
1222             }
1223             CloseHandle( h );
1224         }
1225     }
1226
1227     SetLastError(0xdeadbeef);
1228     h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, 0 );
1229     ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
1230
1231     SetLastError(0xdeadbeef);
1232     h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1233     ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
1234     ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %d\n", GetLastError() );
1235
1236     h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
1237     ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
1238
1239     CloseHandle(h);
1240     CloseHandle(h2);
1241
1242     DeleteFileA( filename );
1243 }
1244
1245 static char get_windows_drive(void)
1246 {
1247     char windowsdir[MAX_PATH];
1248     GetWindowsDirectory(windowsdir, sizeof(windowsdir));
1249     return windowsdir[0];
1250 }
1251
1252 static void test_FindFirstFileA(void)
1253 {
1254     HANDLE handle;
1255     WIN32_FIND_DATAA data;
1256     int err;
1257     char buffer[5] = "C:\\";
1258     char buffer2[100];
1259
1260     /* try FindFirstFileA on "C:\" */
1261     buffer[0] = get_windows_drive();
1262
1263     SetLastError( 0xdeadbeaf );
1264     handle = FindFirstFileA(buffer, &data);
1265     err = GetLastError();
1266     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on root directory should fail\n" );
1267     ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
1268
1269     /* try FindFirstFileA on "C:\*" */
1270     strcpy(buffer2, buffer);
1271     strcat(buffer2, "*");
1272     handle = FindFirstFileA(buffer2, &data);
1273     ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
1274     ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
1275          "FindFirstFile shouldn't return '%s' in drive root\n", data.cFileName );
1276     if (FindNextFileA( handle, &data ))
1277         ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
1278              "FindNextFile shouldn't return '%s' in drive root\n", data.cFileName );
1279     ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
1280
1281     /* try FindFirstFileA on windows dir */
1282     GetWindowsDirectory( buffer2, sizeof(buffer2) );
1283     strcat(buffer2, "\\*");
1284     handle = FindFirstFileA(buffer2, &data);
1285     ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
1286     ok( !strcmp( data.cFileName, "." ), "FindFirstFile should return '.' first\n" );
1287     ok( FindNextFileA( handle, &data ), "FindNextFile failed\n" );
1288     ok( !strcmp( data.cFileName, ".." ), "FindNextFile should return '..' as second entry\n" );
1289     while (FindNextFileA( handle, &data ))
1290         ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
1291              "FindNextFile shouldn't return '%s'\n", data.cFileName );
1292     ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
1293
1294     /* try FindFirstFileA on "C:\foo\" */
1295     SetLastError( 0xdeadbeaf );
1296     strcpy(buffer2, buffer);
1297     strcat(buffer2, "foo\\");
1298     handle = FindFirstFileA(buffer2, &data);
1299     err = GetLastError();
1300     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1301     todo_wine {
1302         ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1303     }
1304
1305     /* try FindFirstFileA on "C:\foo\bar.txt" */
1306     SetLastError( 0xdeadbeaf );
1307     strcpy(buffer2, buffer);
1308     strcat(buffer2, "foo\\bar.txt");
1309     handle = FindFirstFileA(buffer2, &data);
1310     err = GetLastError();
1311     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1312     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1313
1314     /* try FindFirstFileA on "C:\foo\*.*" */
1315     SetLastError( 0xdeadbeaf );
1316     strcpy(buffer2, buffer);
1317     strcat(buffer2, "foo\\*.*");
1318     handle = FindFirstFileA(buffer2, &data);
1319     err = GetLastError();
1320     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1321     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1322
1323     /* try FindFirstFileA on "foo\bar.txt" */
1324     SetLastError( 0xdeadbeaf );
1325     strcpy(buffer2, "foo\\bar.txt");
1326     handle = FindFirstFileA(buffer2, &data);
1327     err = GetLastError();
1328     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1329     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1330
1331     /* try FindFirstFileA on "c:\nul" */
1332     SetLastError( 0xdeadbeaf );
1333     strcpy(buffer2, buffer);
1334     strcat(buffer2, "nul");
1335     handle = FindFirstFileA(buffer2, &data);
1336     err = GetLastError();
1337     ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed\n", buffer2 );
1338     ok( 0 == lstrcmpiA(data.cFileName, "nul"), "wrong name %s\n", data.cFileName );
1339     ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
1340     ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
1341     ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes, "wrong attributes %x\n", data.dwFileAttributes );
1342     SetLastError( 0xdeadbeaf );
1343     ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
1344     ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
1345     ok( FindClose( handle ), "failed to close handle\n" );
1346
1347     /* try FindFirstFileA on "lpt1" */
1348     SetLastError( 0xdeadbeaf );
1349     strcpy(buffer2, "lpt1");
1350     handle = FindFirstFileA(buffer2, &data);
1351     err = GetLastError();
1352     ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed\n", buffer2 );
1353     ok( 0 == lstrcmpiA(data.cFileName, "lpt1"), "wrong name %s\n", data.cFileName );
1354     ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
1355     ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
1356     ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes, "wrong attributes %x\n", data.dwFileAttributes );
1357     SetLastError( 0xdeadbeaf );
1358     ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
1359     ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
1360     ok( FindClose( handle ), "failed to close handle\n" );
1361
1362     /* try FindFirstFileA on "c:\nul\*" */
1363     SetLastError( 0xdeadbeaf );
1364     strcpy(buffer2, buffer);
1365     strcat(buffer2, "nul\\*");
1366     handle = FindFirstFileA(buffer2, &data);
1367     err = GetLastError();
1368     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1369     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1370
1371     /* try FindFirstFileA on "c:\nul*" */
1372     SetLastError( 0xdeadbeaf );
1373     strcpy(buffer2, buffer);
1374     strcat(buffer2, "nul*");
1375     handle = FindFirstFileA(buffer2, &data);
1376     err = GetLastError();
1377     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1378     ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
1379
1380     /* try FindFirstFileA on "c:\foo\bar\nul" */
1381     SetLastError( 0xdeadbeaf );
1382     strcpy(buffer2, buffer);
1383     strcat(buffer2, "foo\\bar\\nul");
1384     handle = FindFirstFileA(buffer2, &data);
1385     err = GetLastError();
1386     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1387     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1388
1389     /* try FindFirstFileA on "c:\foo\nul\bar" */
1390     SetLastError( 0xdeadbeaf );
1391     strcpy(buffer2, buffer);
1392     strcat(buffer2, "foo\\nul\\bar");
1393     handle = FindFirstFileA(buffer2, &data);
1394     err = GetLastError();
1395     ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should Fail\n", buffer2 );
1396     ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
1397 }
1398
1399 static void test_FindNextFileA(void)
1400 {
1401     HANDLE handle;
1402     WIN32_FIND_DATAA search_results;
1403     int err;
1404     char buffer[5] = "C:\\*";
1405
1406     buffer[0] = get_windows_drive();
1407     handle = FindFirstFileA(buffer,&search_results);
1408     ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
1409     while (FindNextFile(handle, &search_results))
1410     {
1411         /* get to the end of the files */
1412     }
1413     ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
1414     err = GetLastError();
1415     ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
1416 }
1417
1418 static void test_FindFirstFileExA(void)
1419 {
1420     WIN32_FIND_DATAA search_results;
1421     HANDLE handle;
1422
1423     CreateDirectoryA("test-dir", NULL);
1424     _lclose(_lcreat("test-dir\\file1", 0));
1425     _lclose(_lcreat("test-dir\\file2", 0));
1426     CreateDirectoryA("test-dir\\dir1", NULL);
1427     /* FindExLimitToDirectories is ignored */
1428     handle = FindFirstFileExA("test-dir\\*", FindExInfoStandard, &search_results, FindExSearchLimitToDirectories, NULL, 0);
1429     ok(handle != INVALID_HANDLE_VALUE, "FindFirstFile failed (err=%u)\n", GetLastError());
1430     ok(strcmp(search_results.cFileName, ".") == 0, "First entry should be '.', is %s\n", search_results.cFileName);
1431
1432 #define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
1433
1434     ok(FindNextFile(handle, &search_results), "Fetching second file failed\n");
1435     ok(strcmp(search_results.cFileName, "..") == 0, "Second entry should be '..' is %s\n", search_results.cFileName);
1436
1437     ok(FindNextFile(handle, &search_results), "Fetching third file failed\n");
1438     ok(CHECK_NAME(search_results.cFileName), "Invalid thrid entry - %s\n", search_results.cFileName);
1439
1440     ok(FindNextFile(handle, &search_results), "Fetching fourth file failed\n");
1441     ok(CHECK_NAME(search_results.cFileName), "Invalid fourth entry - %s\n", search_results.cFileName);
1442
1443     ok(FindNextFile(handle, &search_results), "Fetching fifth file failed\n");
1444     ok(CHECK_NAME(search_results.cFileName), "Invalid fifth entry - %s\n", search_results.cFileName);
1445
1446 #undef CHECK_NAME
1447
1448     ok(FindNextFile(handle, &search_results) == FALSE, "Fetching sixth file should failed\n");
1449     DeleteFileA("test-dir\\file1");
1450     DeleteFileA("test-dir\\file2");
1451     RemoveDirectoryA("test-dir\\dir1");
1452     RemoveDirectoryA("test-dir");
1453 }
1454
1455 static int test_Mapfile_createtemp(HANDLE *handle)
1456 {
1457     SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL);
1458     DeleteFile(filename);
1459     *handle = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 0,
1460                          CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1461     if (*handle != INVALID_HANDLE_VALUE) {
1462
1463         return 1;
1464     }
1465
1466     return 0;
1467 }
1468
1469 static void test_MapFile(void)
1470 {
1471     HANDLE handle;
1472     HANDLE hmap;
1473
1474     ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
1475
1476     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
1477     ok( hmap != NULL, "mapping should work, I named it!\n" );
1478
1479     ok( CloseHandle( hmap ), "can't close mapping handle\n");
1480
1481     /* We have to close file before we try new stuff with mapping again.
1482        Else we would always succeed on XP or block descriptors on 95. */
1483     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
1484     ok( hmap != NULL, "We should still be able to map!\n" );
1485     ok( CloseHandle( hmap ), "can't close mapping handle\n");
1486     ok( CloseHandle( handle ), "can't close file handle\n");
1487     handle = NULL;
1488
1489     ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
1490
1491     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
1492     ok( hmap == NULL, "mapped zero size file\n");
1493     ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
1494
1495     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0, NULL );
1496     ok( hmap == NULL, "mapping should fail\n");
1497     /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1498
1499     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x80000000, 0x10000, NULL );
1500     ok( hmap == NULL, "mapping should fail\n");
1501     /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1502
1503     /* On XP you can now map again, on Win 95 you cannot. */
1504
1505     ok( CloseHandle( handle ), "can't close file handle\n");
1506     ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
1507 }
1508
1509 static void test_GetFileType(void)
1510 {
1511     DWORD type;
1512     HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1513     ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
1514     type = GetFileType(h);
1515     ok( type == FILE_TYPE_DISK, "expected type disk got %d\n", type );
1516     CloseHandle( h );
1517     h = CreateFileA( "nul", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
1518     ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
1519     type = GetFileType(h);
1520     ok( type == FILE_TYPE_CHAR, "expected type char for nul got %d\n", type );
1521     CloseHandle( h );
1522     DeleteFileA( filename );
1523 }
1524
1525 static int completion_count;
1526
1527 static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
1528 {
1529 /*      printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
1530         ReleaseSemaphore(ovl->hEvent, 1, NULL);
1531         completion_count++;
1532 }
1533
1534 static void test_async_file_errors(void)
1535 {
1536     char szFile[MAX_PATH];
1537     HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
1538     HANDLE hFile;
1539     LPVOID lpBuffer = HeapAlloc(GetProcessHeap(), 0, 4096);
1540     OVERLAPPED ovl;
1541     S(U(ovl)).Offset = 0;
1542     S(U(ovl)).OffsetHigh = 0;
1543     ovl.hEvent = hSem;
1544     completion_count = 0;
1545     szFile[0] = '\0';
1546     GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
1547     strcat(szFile, "\\win.ini");
1548     hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
1549     ok(hFile != NULL, "CreateFileA(%s ...) failed\n", szFile);
1550     while (TRUE)
1551     {
1552         BOOL res;
1553         while (WaitForSingleObjectEx(hSem, INFINITE, TRUE) == WAIT_IO_COMPLETION)
1554             ;
1555         res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
1556         /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
1557         if (!res)
1558             break;
1559         S(U(ovl)).Offset += 4096;
1560         /* i/o completion routine only called if ReadFileEx returned success.
1561          * we only care about violations of this rule so undo what should have
1562          * been done */
1563         completion_count--;
1564     }
1565     ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
1566     /*printf("Error = %ld\n", GetLastError());*/
1567 }
1568
1569 static void test_read_write(void)
1570 {
1571     DWORD bytes, ret;
1572     HANDLE hFile;
1573     char temp_path[MAX_PATH];
1574     char filename[MAX_PATH];
1575     static const char prefix[] = "pfx";
1576
1577     ret = GetTempPathA(MAX_PATH, temp_path);
1578     ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1579     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1580
1581     ret = GetTempFileNameA(temp_path, prefix, 0, filename);
1582     ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1583
1584     hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
1585                         CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
1586     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
1587
1588     SetLastError(12345678);
1589     bytes = 12345678;
1590     ret = WriteFile(hFile, NULL, 0, &bytes, NULL);
1591     ok(ret && GetLastError() == 12345678,
1592         "ret = %d, error %d\n", ret, GetLastError());
1593     ok(!bytes, "bytes = %d\n", bytes);
1594
1595     SetLastError(12345678);
1596     bytes = 12345678;
1597     ret = WriteFile(hFile, NULL, 10, &bytes, NULL);
1598     ok((!ret && GetLastError() == ERROR_INVALID_USER_BUFFER) || /* Win2k */
1599         (ret && GetLastError() == 12345678), /* Win9x */
1600         "ret = %d, error %d\n", ret, GetLastError());
1601     ok(!bytes || /* Win2k */
1602         bytes == 10, /* Win9x */
1603         "bytes = %d\n", bytes);
1604
1605     /* make sure the file contains data */
1606     WriteFile(hFile, "this is the test data", 21, &bytes, NULL);
1607     SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
1608
1609     SetLastError(12345678);
1610     bytes = 12345678;
1611     ret = ReadFile(hFile, NULL, 0, &bytes, NULL);
1612     ok(ret && GetLastError() == 12345678,
1613         "ret = %d, error %d\n", ret, GetLastError());
1614     ok(!bytes, "bytes = %d\n", bytes);
1615
1616     SetLastError(12345678);
1617     bytes = 12345678;
1618     ret = ReadFile(hFile, NULL, 10, &bytes, NULL);
1619     ok(!ret && (GetLastError() == ERROR_NOACCESS || /* Win2k */
1620                 GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
1621         "ret = %d, error %d\n", ret, GetLastError());
1622     ok(!bytes, "bytes = %d\n", bytes);
1623
1624     ret = CloseHandle(hFile);
1625     ok( ret, "CloseHandle: error %d\n", GetLastError());
1626     ret = DeleteFileA(filename);
1627     ok( ret, "DeleteFileA: error %d\n", GetLastError());
1628 }
1629
1630 static void test_OpenFile(void)
1631 {
1632     HFILE hFile;
1633     OFSTRUCT ofs;
1634     BOOL ret;
1635     DWORD retval;
1636
1637     static const char *file = "\\regsvr32.exe";
1638     static const char *foo = ".\\foo-bar-foo.baz";
1639     static const char *foo_too_long = ".\\foo-bar-foo.baz+++++++++++++++"
1640         "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
1641         "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
1642         "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
1643         "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
1644         "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
1645     static const char *backslash = "\\";
1646     char buff[MAX_PATH];
1647     char buff_long[4*MAX_PATH];
1648     char filled_0xA5[OFS_MAXPATHNAME];
1649     UINT length;
1650
1651     /* Check for existing file */
1652     length = GetSystemDirectoryA(buff, MAX_PATH);
1653
1654     if (length + lstrlen(file) < MAX_PATH)
1655     {
1656         lstrcatA(buff, file);
1657         memset(&ofs, 0xA5, sizeof(ofs));
1658         SetLastError(0xfaceabee);
1659
1660         hFile = OpenFile(buff, &ofs, OF_EXIST);
1661         ok( hFile == TRUE, "%s not found : %d\n", buff, GetLastError() );
1662         ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1663             "GetLastError() returns %d\n", GetLastError() );
1664         ok( ofs.cBytes == sizeof(ofs), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1665         ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1666         ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1667             "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
1668             ofs.szPathName, buff );
1669     }
1670
1671     memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
1672     length = GetCurrentDirectoryA(MAX_PATH, buff);
1673
1674     /* Check for nonexistent file */
1675     if (length + lstrlenA(foo + 1) < MAX_PATH)
1676     {
1677         lstrcatA(buff, foo + 1); /* Avoid '.' during concatenation */
1678         memset(&ofs, 0xA5, sizeof(ofs));
1679         SetLastError(0xfaceabee);
1680
1681         hFile = OpenFile(foo, &ofs, OF_EXIST);
1682         ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
1683         ok( GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError() returns %d\n", GetLastError() );
1684         todo_wine
1685         ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1686         ok( ofs.nErrCode == ERROR_FILE_NOT_FOUND, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1687         ok( lstrcmpiA(ofs.szPathName, buff) == 0 || strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
1688             "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
1689             ofs.szPathName, buff );
1690     }
1691
1692     length = GetCurrentDirectoryA(MAX_PATH, buff_long);
1693     length += lstrlenA(foo_too_long + 1);
1694
1695     /* Check for nonexistent file with too long filename */
1696     if (length >= OFS_MAXPATHNAME && length < sizeof(buff_long))
1697     {
1698         lstrcatA(buff_long, foo_too_long + 1); /* Avoid '.' during concatenation */
1699         memset(&ofs, 0xA5, sizeof(ofs));
1700         SetLastError(0xfaceabee);
1701
1702         hFile = OpenFile(foo_too_long, &ofs, OF_EXIST);
1703         ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
1704         ok( GetLastError() == ERROR_INVALID_DATA || GetLastError() == ERROR_FILENAME_EXCED_RANGE,
1705             "GetLastError() returns %d\n", GetLastError() );
1706         todo_wine
1707         ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1708         ok( ofs.nErrCode == ERROR_INVALID_DATA || ofs.nErrCode == ERROR_FILENAME_EXCED_RANGE,
1709             "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1710         ok( strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
1711             "OpenFile returned '%s', but was expected to return string filled with 0xA5\n",
1712             ofs.szPathName );
1713     }
1714
1715     length = GetCurrentDirectoryA(MAX_PATH, buff);
1716     length += lstrlenA(backslash);
1717     length += lstrlenA(filename);
1718
1719     if (length >= MAX_PATH)
1720     {
1721         trace("Buffer too small, requested length = %d, but MAX_PATH = %d.  Skipping test.\n", length, MAX_PATH);
1722         return;
1723     }
1724     lstrcatA(buff, backslash);
1725     lstrcatA(buff, filename);
1726
1727     memset(&ofs, 0xA5, sizeof(ofs));
1728     SetLastError(0xfaceabee);
1729     /* Create an empty file */
1730     hFile = OpenFile(filename, &ofs, OF_CREATE);
1731     ok( hFile != HFILE_ERROR, "OpenFile failed to create nonexistent file\n" );
1732     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1733         "GetLastError() returns %d\n", GetLastError() );
1734     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1735     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1736     ret = CloseHandle((HANDLE)hFile);
1737     ok( ret == TRUE, "CloseHandle() returns %d\n", ret );
1738     retval = GetFileAttributesA(filename);
1739     ok( retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %d\n", GetLastError() );
1740
1741     memset(&ofs, 0xA5, sizeof(ofs));
1742     SetLastError(0xfaceabee);
1743     /* Check various opening options: */
1744     /* for reading only, */
1745     hFile = OpenFile(filename, &ofs, OF_READ);
1746     ok( hFile != HFILE_ERROR, "OpenFile failed on read\n" );
1747     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1748         "GetLastError() returns %d\n", GetLastError() );
1749     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1750     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1751     ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1752         "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
1753     ret = CloseHandle((HANDLE)hFile);
1754     ok( ret == TRUE, "CloseHandle() returns %d\n", ret );
1755
1756     memset(&ofs, 0xA5, sizeof(ofs));
1757     SetLastError(0xfaceabee);
1758     /* for writing only, */
1759     hFile = OpenFile(filename, &ofs, OF_WRITE);
1760     ok( hFile != HFILE_ERROR, "OpenFile failed on write\n" );
1761     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1762         "GetLastError() returns %d\n", GetLastError() );
1763     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1764     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1765     ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1766         "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
1767     ret = CloseHandle((HANDLE)hFile);
1768     ok( ret == TRUE, "CloseHandle() returns %d\n", ret );
1769
1770     memset(&ofs, 0xA5, sizeof(ofs));
1771     SetLastError(0xfaceabee);
1772     /* for reading and writing, */
1773     hFile = OpenFile(filename, &ofs, OF_READWRITE);
1774     ok( hFile != HFILE_ERROR, "OpenFile failed on read/write\n" );
1775     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1776         "GetLastError() returns %d\n", GetLastError() );
1777     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1778     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1779     ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1780         "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
1781     ret = CloseHandle((HANDLE)hFile);
1782     ok( ret == TRUE, "CloseHandle() returns %d\n", ret );
1783
1784     memset(&ofs, 0xA5, sizeof(ofs));
1785     SetLastError(0xfaceabee);
1786     /* for checking file presence. */
1787     hFile = OpenFile(filename, &ofs, OF_EXIST);
1788     ok( hFile == 1, "OpenFile failed on finding our created file\n" );
1789     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1790         "GetLastError() returns %d\n", GetLastError() );
1791     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1792     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1793     ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1794         "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
1795
1796     memset(&ofs, 0xA5, sizeof(ofs));
1797     SetLastError(0xfaceabee);
1798     /* Delete the file and make sure it doesn't exist anymore */
1799     hFile = OpenFile(filename, &ofs, OF_DELETE);
1800     ok( hFile == 1, "OpenFile failed on delete (%d)\n", hFile );
1801     ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
1802         "GetLastError() returns %d\n", GetLastError() );
1803     ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
1804     ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
1805     ok( lstrcmpiA(ofs.szPathName, buff) == 0,
1806         "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
1807
1808     retval = GetFileAttributesA(filename);
1809     ok( retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file\n" );
1810 }
1811
1812 static void test_overlapped(void)
1813 {
1814     OVERLAPPED ov;
1815     DWORD r, result;
1816
1817     /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
1818
1819     memset( &ov, 0,  sizeof ov );
1820     result = 1;
1821     r = GetOverlappedResult(0, &ov, &result, 0);
1822     ok( r == TRUE, "should return false\n");
1823     ok( result == 0, "wrong result %u\n", result );
1824
1825     result = 0;
1826     ov.Internal = 0;
1827     ov.InternalHigh = 0xabcd;
1828     r = GetOverlappedResult(0, &ov, &result, 0);
1829     ok( r == TRUE, "should return false\n");
1830     ok( result == 0xabcd, "wrong result %u\n", result );
1831
1832     SetLastError( 0xb00 );
1833     result = 0;
1834     ov.Internal = STATUS_INVALID_HANDLE;
1835     ov.InternalHigh = 0xabcd;
1836     r = GetOverlappedResult(0, &ov, &result, 0);
1837     ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
1838     ok( r == FALSE, "should return false\n");
1839     ok( result == 0xabcd, "wrong result %u\n", result );
1840
1841     SetLastError( 0xb00 );
1842     result = 0;
1843     ov.Internal = STATUS_PENDING;
1844     ov.InternalHigh = 0xabcd;
1845     r = GetOverlappedResult(0, &ov, &result, 0);
1846     ok( GetLastError() == ERROR_IO_INCOMPLETE, "wrong error %u\n", GetLastError() );
1847     ok( r == FALSE, "should return false\n");
1848     ok( result == 0, "wrong result %u\n", result );
1849
1850     SetLastError( 0xb00 );
1851     ov.hEvent = CreateEvent( NULL, 1, 1, NULL );
1852     ov.Internal = STATUS_PENDING;
1853     ov.InternalHigh = 0xabcd;
1854     r = GetOverlappedResult(0, &ov, &result, 0);
1855     ok( GetLastError() == ERROR_IO_INCOMPLETE, "wrong error %u\n", GetLastError() );
1856     ok( r == FALSE, "should return false\n");
1857
1858     ResetEvent( ov.hEvent );
1859
1860     SetLastError( 0xb00 );
1861     ov.Internal = STATUS_PENDING;
1862     ov.InternalHigh = 0;
1863     r = GetOverlappedResult(0, &ov, &result, 0);
1864     ok( GetLastError() == ERROR_IO_INCOMPLETE, "wrong error %u\n", GetLastError() );
1865     ok( r == FALSE, "should return false\n");
1866
1867     r = CloseHandle( ov.hEvent );
1868     ok( r == TRUE, "close handle failed\n");
1869 }
1870
1871 static void test_RemoveDirectory(void)
1872 {
1873     int rc;
1874     char directory[] = "removeme";
1875
1876     rc = CreateDirectory(directory, NULL);
1877     ok( rc, "Createdirectory failed, gle=%d\n", GetLastError() );
1878
1879     rc = SetCurrentDirectory(directory);
1880     ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
1881
1882     rc = RemoveDirectory(".");
1883     todo_wine {
1884     ok( !rc, "RemoveDirectory unexpectedly worked\n" );
1885     }
1886
1887     rc = SetCurrentDirectory("..");
1888     ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
1889
1890     rc = RemoveDirectory(directory);
1891     todo_wine {
1892     ok( rc, "RemoveDirectory failed, gle=%d\n", GetLastError() );
1893     }
1894 }
1895
1896 START_TEST(file)
1897 {
1898     test__hread(  );
1899     test__hwrite(  );
1900     test__lclose(  );
1901     test__lcreat(  );
1902     test__llseek(  );
1903     test__llopen(  );
1904     test__lread(  );
1905     test__lwrite(  );
1906     test_GetTempFileNameA();
1907     test_CopyFileA();
1908     test_CopyFileW();
1909     test_CreateFileA();
1910     test_CreateFileW();
1911     test_DeleteFileA();
1912     test_DeleteFileW();
1913     test_MoveFileA();
1914     test_MoveFileW();
1915     test_FindFirstFileA();
1916     test_FindNextFileA();
1917     test_FindFirstFileExA();
1918     test_LockFile();
1919     test_file_sharing();
1920     test_offset_in_overlapped_structure();
1921     test_MapFile();
1922     test_GetFileType();
1923     test_async_file_errors();
1924     test_read_write();
1925     test_OpenFile();
1926     test_overlapped();
1927     test_RemoveDirectory();
1928 }