dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 static int dll_capable(const char *dll, const char *function)
  32 {
  33     HMODULE module = GetModuleHandleA(dll);
  34     if (!module) return 0;
  35
  36     return (GetProcAddress(module, function) != NULL);
  37 }
  38
  39
  40 LPCSTR filename = "testfile.xxx";
  41 LPCSTR sillytext =
  42 "en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
  43 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  44 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  45 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  46 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  47 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  48 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  49 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  50 "1234 43 4kljf lf &%%%&&&&&& 34 4 34   3############# 33 3 3 3 # 3## 3"
  51 "sdlkfjasdlkfj a dslkj adsklf  \n  \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
  52
  53
  54 static void test__hread( void )
  55 {
  56     HFILE filehandle;
  57     char buffer[10000];
  58     long bytes_read;
  59     long bytes_wanted;
  60     long i;
  61     BOOL ret;
  62
  63     SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
  64     DeleteFileA( filename );
  65     filehandle = _lcreat( filename, 0 );
  66     if (filehandle == HFILE_ERROR)
  67     {
  68         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
  69         return;
  70     }
  71
  72     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
  73
  74     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
  75
  76     filehandle = _lopen( filename, OF_READ );
  77
  78     ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%ld)\n", filename, GetLastError(  ) );
  79
  80     bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
  81
  82     ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
  83
  84     for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
  85     {
  86         ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
  87         ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
  88         for (i = 0; i < bytes_wanted; i++)
  89         {
  90             ok( buffer[i] == sillytext[i], "that's not what's written\n" );
  91         }
  92     }
  93
  94     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
  95
  96     ret = DeleteFileA( filename );
  97     ok( ret != 0, "DeleteFile failed (%ld)\n", GetLastError(  ) );
  98 }
  99
 100
 101 static void test__hwrite( void )
 102 {
 103     HFILE filehandle;
 104     char buffer[10000];
 105     long bytes_read;
 106     long bytes_written;
 107     long blocks;
 108     long i;
 109     char *contents;
 110     HLOCAL memory_object;
 111     char checksum[1];
 112     BOOL ret;
 113
 114     filehandle = _lcreat( filename, 0 );
 115     if (filehandle == HFILE_ERROR)
 116     {
 117         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 118         return;
 119     }
 120
 121     ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
 122
 123     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 124
 125     filehandle = _lopen( filename, OF_READ );
 126
 127     bytes_read = _hread( filehandle, buffer, 1);
 128
 129     ok( 0 == bytes_read, "file read size error\n" );
 130
 131     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 132
 133     filehandle = _lopen( filename, OF_READWRITE );
 134
 135     bytes_written = 0;
 136     checksum[0] = '\0';
 137     srand( (unsigned)time( NULL ) );
 138     for (blocks = 0; blocks < 100; blocks++)
 139     {
 140         for (i = 0; i < (long)sizeof( buffer ); i++)
 141         {
 142             buffer[i] = rand(  );
 143             checksum[0] = checksum[0] + buffer[i];
 144         }
 145         ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
 146         bytes_written = bytes_written + sizeof( buffer );
 147     }
 148
 149     ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
 150     bytes_written++;
 151
 152     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 153
 154     memory_object = LocalAlloc( LPTR, bytes_written );
 155
 156     ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
 157
 158     contents = LocalLock( memory_object );
 159
 160     filehandle = _lopen( filename, OF_READ );
 161
 162     contents = LocalLock( memory_object );
 163
 164     ok( NULL != contents, "LocalLock whines\n" );
 165
 166     ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
 167
 168     checksum[0] = '\0';
 169     i = 0;
 170     do
 171     {
 172         checksum[0] = checksum[0] + contents[i];
 173         i++;
 174     }
 175     while (i < bytes_written - 1);
 176
 177     ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
 178
 179     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 180
 181     ret = DeleteFileA( filename );
 182     ok( ret != 0, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 183 }
 184
 185
 186 static void test__lclose( void )
 187 {
 188     HFILE filehandle;
 189     BOOL ret;
 190
 191     filehandle = _lcreat( filename, 0 );
 192     if (filehandle == HFILE_ERROR)
 193     {
 194         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 195         return;
 196     }
 197
 198     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 199
 200     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 201
 202     ret = DeleteFileA( filename );
 203     ok( ret != 0, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 204 }
 205
 206
 207 static void test__lcreat( void )
 208 {
 209     HFILE filehandle;
 210     char buffer[10000];
 211     WIN32_FIND_DATAA search_results;
 212     char slashname[] = "testfi/";
 213     int err;
 214     HANDLE find;
 215     BOOL ret;
 216
 217     filehandle = _lcreat( filename, 0 );
 218     if (filehandle == HFILE_ERROR)
 219     {
 220         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 221         return;
 222     }
 223
 224     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 225
 226     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 227
 228     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 229
 230     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 231
 232     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should be able to find file\n" );
 233
 234     ret = DeleteFileA(filename);
 235     ok( ret != 0, "DeleteFile failed (%ld)\n", GetLastError());
 236
 237     filehandle = _lcreat( filename, 1 ); /* readonly */
 238     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%ld)\n", filename, GetLastError(  ) );
 239
 240     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
 241
 242     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 243
 244     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should be able to find file\n" );
 245
 246     ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
 247
 248     ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
 249
 250     ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
 251
 252     filehandle = _lcreat( filename, 2 );
 253     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%ld)\n", filename, GetLastError(  ) );
 254
 255     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 256
 257     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 258
 259     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 260
 261     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 262
 263     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should STILL be able to find file\n" );
 264
 265     ret = DeleteFileA( filename );
 266     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 267
 268     filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
 269     ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%ld)\n", filename, GetLastError(  ) );
 270
 271     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 272
 273     ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 274
 275     ok( _hread( filehandle, buffer, strlen( sillytext ) ) ==  lstrlenA( sillytext ), "erratic _hread return value\n" );
 276
 277     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 278
 279     ok( INVALID_HANDLE_VALUE != FindFirstFileA( filename, &search_results ), "should STILL be able to find file\n" );
 280
 281     ret = DeleteFileA( filename );
 282     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 283
 284     filehandle=_lcreat (slashname, 0); /* illegal name */
 285     if (HFILE_ERROR==filehandle) {
 286       err=GetLastError ();
 287       ok (err==ERROR_INVALID_NAME || err==ERROR_PATH_NOT_FOUND,
 288           "creating file \"%s\" failed with error %d\n", slashname, err);
 289     } else { /* only NT succeeds */
 290       _lclose(filehandle);
 291       find=FindFirstFileA (slashname, &search_results);
 292       if (INVALID_HANDLE_VALUE!=find)
 293       {
 294         ret = FindClose (find);
 295         ok (0 != ret, "FindClose complains (%ld)\n", GetLastError ());
 296         slashname[strlen(slashname)-1]=0;
 297         ok (!strcmp (slashname, search_results.cFileName),
 298             "found unexpected name \"%s\"\n", search_results.cFileName);
 299         ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
 300             "attributes of file \"%s\" are 0x%04lx\n", search_results.cFileName,
 301             search_results.dwFileAttributes);
 302       }
 303     ret = DeleteFileA( slashname );
 304     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 305     }
 306
 307     filehandle=_lcreat (filename, 8); /* illegal attribute */
 308     if (HFILE_ERROR==filehandle)
 309       ok (0, "couldn't create volume label \"%s\"\n", filename);
 310     else {
 311       _lclose(filehandle);
 312       find=FindFirstFileA (filename, &search_results);
 313       if (INVALID_HANDLE_VALUE==find)
 314         ok (0, "file \"%s\" not found\n", filename);
 315       else {
 316         ret = FindClose(find);
 317         ok ( 0 != ret, "FindClose complains (%ld)\n", GetLastError ());
 318         ok (!strcmp (filename, search_results.cFileName),
 319             "found unexpected name \"%s\"\n", search_results.cFileName);
 320         ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
 321             "attributes of file \"%s\" are 0x%04lx\n", search_results.cFileName,
 322             search_results.dwFileAttributes);
 323       }
 324     ret = DeleteFileA( filename );
 325     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 326     }
 327 }
 328
 329
 330 static void test__llseek( void )
 331 {
 332     INT i;
 333     HFILE filehandle;
 334     char buffer[1];
 335     long bytes_read;
 336     BOOL ret;
 337
 338     filehandle = _lcreat( filename, 0 );
 339     if (filehandle == HFILE_ERROR)
 340     {
 341         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 342         return;
 343     }
 344
 345     for (i = 0; i < 400; i++)
 346     {
 347         ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 348     }
 349     ok( HFILE_ERROR != _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ), "should be able to seek\n" );
 350     ok( HFILE_ERROR != _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ), "should be able to seek\n" );
 351
 352     bytes_read = _hread( filehandle, buffer, 1);
 353     ok( 1 == bytes_read, "file read size error\n" );
 354     ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
 355     ok( HFILE_ERROR != _llseek( filehandle, -400 * strlen( sillytext ), FILE_END ), "should be able to seek\n" );
 356
 357     bytes_read = _hread( filehandle, buffer, 1);
 358     ok( 1 == bytes_read, "file read size error\n" );
 359     ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
 360     ok( HFILE_ERROR != _llseek( filehandle, 1000000, FILE_END ), "should be able to seek past file; poor, poor Windows programmers\n" );
 361     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 362
 363     ret = DeleteFileA( filename );
 364     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 365 }
 366
 367
 368 static void test__llopen( void )
 369 {
 370     HFILE filehandle;
 371     UINT bytes_read;
 372     char buffer[10000];
 373     BOOL ret;
 374
 375     filehandle = _lcreat( filename, 0 );
 376     if (filehandle == HFILE_ERROR)
 377     {
 378         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 379         return;
 380     }
 381
 382     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 383     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 384
 385     filehandle = _lopen( filename, OF_READ );
 386     ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
 387     bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
 388     ok( strlen( sillytext )  == bytes_read, "file read size error\n" );
 389     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 390
 391     filehandle = _lopen( filename, OF_READWRITE );
 392     bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
 393     ok( strlen( sillytext )  == bytes_read, "file read size error\n" );
 394     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
 395     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 396
 397     filehandle = _lopen( filename, OF_WRITE );
 398     ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
 399     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
 400     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 401
 402     ret = DeleteFileA( filename );
 403     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 404     /* TODO - add tests for the SHARE modes  -  use two processes to pull this one off */
 405 }
 406
 407
 408 static void test__lread( void )
 409 {
 410     HFILE filehandle;
 411     char buffer[10000];
 412     long bytes_read;
 413     UINT bytes_wanted;
 414     UINT i;
 415     BOOL ret;
 416
 417     filehandle = _lcreat( filename, 0 );
 418     if (filehandle == HFILE_ERROR)
 419     {
 420         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 421         return;
 422     }
 423
 424     ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
 425
 426     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 427
 428     filehandle = _lopen( filename, OF_READ );
 429
 430     ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%ld)\n", filename, GetLastError());
 431
 432     bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
 433
 434     ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
 435
 436     for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
 437     {
 438         ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
 439         ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
 440         for (i = 0; i < bytes_wanted; i++)
 441         {
 442             ok( buffer[i] == sillytext[i], "that's not what's written\n" );
 443         }
 444     }
 445
 446     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 447
 448     ret = DeleteFileA( filename );
 449     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 450 }
 451
 452
 453 static void test__lwrite( void )
 454 {
 455     HFILE filehandle;
 456     char buffer[10000];
 457     long bytes_read;
 458     long bytes_written;
 459     long blocks;
 460     long i;
 461     char *contents;
 462     HLOCAL memory_object;
 463     char checksum[1];
 464     BOOL ret;
 465
 466     filehandle = _lcreat( filename, 0 );
 467     if (filehandle == HFILE_ERROR)
 468     {
 469         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 470         return;
 471     }
 472
 473     ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
 474
 475     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 476
 477     filehandle = _lopen( filename, OF_READ );
 478
 479     bytes_read = _hread( filehandle, buffer, 1);
 480
 481     ok( 0 == bytes_read, "file read size error\n" );
 482
 483     ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
 484
 485     filehandle = _lopen( filename, OF_READWRITE );
 486
 487     bytes_written = 0;
 488     checksum[0] = '\0';
 489     srand( (unsigned)time( NULL ) );
 490     for (blocks = 0; blocks < 100; blocks++)
 491     {
 492         for (i = 0; i < (long)sizeof( buffer ); i++)
 493         {
 494             buffer[i] = rand(  );
 495             checksum[0] = checksum[0] + buffer[i];
 496         }
 497         ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
 498         bytes_written = bytes_written + sizeof( buffer );
 499     }
 500
 501     ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
 502     bytes_written++;
 503
 504     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 505
 506     memory_object = LocalAlloc( LPTR, bytes_written );
 507
 508     ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
 509
 510     contents = LocalLock( memory_object );
 511
 512     filehandle = _lopen( filename, OF_READ );
 513
 514     contents = LocalLock( memory_object );
 515
 516     ok( NULL != contents, "LocalLock whines\n" );
 517
 518     ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
 519
 520     checksum[0] = '\0';
 521     i = 0;
 522     do
 523     {
 524         checksum[0] += contents[i];
 525         i++;
 526     }
 527     while (i < bytes_written - 1);
 528
 529     ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
 530
 531     ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
 532
 533     ret = DeleteFileA( filename );
 534     ok( ret, "DeleteFile failed (%ld)\n", GetLastError(  ) );
 535 }
 536
 537 static void test_CopyFileA(void)
 538 {
 539     char temp_path[MAX_PATH];
 540     char source[MAX_PATH], dest[MAX_PATH];
 541     static const char prefix[] = "pfx";
 542     HANDLE hfile;
 543     FILETIME ft1, ft2;
 544     char buf[10];
 545     DWORD ret;
 546     BOOL retok;
 547
 548     ret = GetTempPathA(MAX_PATH, temp_path);
 549     ok(ret != 0, "GetTempPathA error %ld\n", GetLastError());
 550     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 551
 552     ret = GetTempFileNameA(temp_path, prefix, 0, source);
 553     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
 554
 555     /* make the source have not zero size */
 556     hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
 557     ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
 558     retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
 559     ok( retok && ret == sizeof(prefix),
 560        "WriteFile error %ld\n", GetLastError());
 561     ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
 562     /* get the file time and change it to prove the difference */
 563     ret = GetFileTime(hfile, NULL, NULL, &ft1);
 564     ok( ret, "GetFileTime error %ld\n", GetLastError());
 565     ft1.dwLowDateTime -= 600000000; /* 60 second */
 566     ret = SetFileTime(hfile, NULL, NULL, &ft1);
 567     ok( ret, "SetFileTime error %ld\n", GetLastError());
 568     GetFileTime(hfile, NULL, NULL, &ft1);  /* get the actual time back */
 569     CloseHandle(hfile);
 570
 571     ret = GetTempFileNameA(temp_path, prefix, 0, dest);
 572     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
 573
 574     SetLastError(0xdeadbeef);
 575     ret = CopyFileA(source, dest, TRUE);
 576     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
 577        "CopyFileA: unexpected error %ld\n", GetLastError());
 578
 579     ret = CopyFileA(source, dest, FALSE);
 580     ok(ret, "CopyFileA: error %ld\n", GetLastError());
 581
 582     /* make sure that destination has correct size */
 583     hfile = CreateFileA(dest, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 584     ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
 585     ret = GetFileSize(hfile, NULL);
 586     ok(ret == sizeof(prefix), "destination file has wrong size %ld\n", ret);
 587
 588     /* make sure that destination has the same filetime */
 589     ret = GetFileTime(hfile, NULL, NULL, &ft2);
 590     ok( ret, "GetFileTime error %ld\n", GetLastError());
 591     ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
 592
 593     SetLastError(0xdeadbeef);
 594     ret = CopyFileA(source, dest, FALSE);
 595     ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION,
 596        "CopyFileA: ret = %ld, unexpected error %ld\n", ret, GetLastError());
 597
 598     /* make sure that destination still has correct size */
 599     ret = GetFileSize(hfile, NULL);
 600     ok(ret == sizeof(prefix), "destination file has wrong size %ld\n", ret);
 601     retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
 602     ok( retok && ret == sizeof(prefix),
 603        "ReadFile: error %ld\n", GetLastError());
 604     ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
 605     CloseHandle(hfile);
 606
 607     ret = DeleteFileA(source);
 608     ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 609     ret = DeleteFileA(dest);
 610     ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 611 }
 612
 613 static void test_CopyFileW(void)
 614 {
 615     WCHAR temp_path[MAX_PATH];
 616     WCHAR source[MAX_PATH], dest[MAX_PATH];
 617     static const WCHAR prefix[] = {'p','f','x',0};
 618     DWORD ret;
 619
 620     ret = GetTempPathW(MAX_PATH, temp_path);
 621     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 622         return;
 623     ok(ret != 0, "GetTempPathW error %ld\n", GetLastError());
 624     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 625
 626     ret = GetTempFileNameW(temp_path, prefix, 0, source);
 627     ok(ret != 0, "GetTempFileNameW error %ld\n", GetLastError());
 628
 629     ret = GetTempFileNameW(temp_path, prefix, 0, dest);
 630     ok(ret != 0, "GetTempFileNameW error %ld\n", GetLastError());
 631
 632     ret = CopyFileW(source, dest, TRUE);
 633     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
 634        "CopyFileW: unexpected error %ld\n", GetLastError());
 635
 636     ret = CopyFileW(source, dest, FALSE);
 637     ok(ret, "CopyFileW: error %ld\n", GetLastError());
 638
 639     ret = DeleteFileW(source);
 640     ok(ret, "DeleteFileW: error %ld\n", GetLastError());
 641     ret = DeleteFileW(dest);
 642     ok(ret, "DeleteFileW: error %ld\n", GetLastError());
 643 }
 644
 645 static void test_CreateFileA(void)
 646 {
 647     HANDLE hFile;
 648     char temp_path[MAX_PATH];
 649     char filename[MAX_PATH];
 650     static const char prefix[] = "pfx";
 651     DWORD ret;
 652
 653     ret = GetTempPathA(MAX_PATH, temp_path);
 654     ok(ret != 0, "GetTempPathA error %ld\n", GetLastError());
 655     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 656
 657     ret = GetTempFileNameA(temp_path, prefix, 0, filename);
 658     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
 659
 660     hFile = CreateFileA(filename, GENERIC_READ, 0, NULL,
 661                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 662     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
 663         "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
 664
 665     ret = DeleteFileA(filename);
 666     ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 667 }
 668
 669 static void test_CreateFileW(void)
 670 {
 671     HANDLE hFile;
 672     WCHAR temp_path[MAX_PATH];
 673     WCHAR filename[MAX_PATH];
 674     static const WCHAR emptyW[]={'\0'};
 675     static const WCHAR prefix[] = {'p','f','x',0};
 676     static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
 677     DWORD ret;
 678
 679     ret = GetTempPathW(MAX_PATH, temp_path);
 680     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 681         return;
 682     ok(ret != 0, "GetTempPathW error %ld\n", GetLastError());
 683     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 684
 685     ret = GetTempFileNameW(temp_path, prefix, 0, filename);
 686     ok(ret != 0, "GetTempFileNameW error %ld\n", GetLastError());
 687
 688     hFile = CreateFileW(filename, GENERIC_READ, 0, NULL,
 689                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 690     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_EXISTS,
 691         "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
 692
 693     ret = DeleteFileW(filename);
 694     ok(ret, "DeleteFileW: error %ld\n", GetLastError());
 695
 696 #if 0  /* this test crashes on NT4.0 */
 697     hFile = CreateFileW(NULL, GENERIC_READ, 0, NULL,
 698                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 699     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
 700        "CreateFileW(NULL) returned ret=%p error=%ld\n",hFile,GetLastError());
 701 #endif
 702
 703     hFile = CreateFileW(emptyW, GENERIC_READ, 0, NULL,
 704                         CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
 705     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PATH_NOT_FOUND,
 706        "CreateFileW(\"\") returned ret=%p error=%ld\n",hFile,GetLastError());
 707
 708     /* test the result of opening a nonexistent driver name */
 709     hFile = CreateFileW(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 710                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 711     ok(hFile == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND,
 712        "CreateFileW on invalid VxD name returned ret=%p error=%ld\n",hFile,GetLastError());
 713 }
 714
 715 static void test_GetTempFileNameA(void)
 716 {
 717     UINT result;
 718     char out[MAX_PATH];
 719     char expected[MAX_PATH + 10];
 720     char windowsdir[MAX_PATH + 10];
 721     char windowsdrive[3];
 722
 723     result = GetWindowsDirectory(windowsdir, sizeof(windowsdir));
 724     ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
 725     ok(result != 0, "GetWindowsDirectory: error %ld\n", GetLastError());
 726
 727     /* If the Windows directory is the root directory, it ends in backslash, not else. */
 728     if (strlen(windowsdir) != 3) /* As in  "C:\"  or  "F:\"  */
 729     {
 730         strcat(windowsdir, "\\");
 731     }
 732
 733     windowsdrive[0] = windowsdir[0];
 734     windowsdrive[1] = windowsdir[1];
 735     windowsdrive[2] = '\0';
 736
 737     result = GetTempFileNameA(windowsdrive, "abc", 1, out);
 738     ok(result != 0, "GetTempFileNameA: error %ld\n", GetLastError());
 739     ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
 740        "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
 741        windowsdrive[0], out);
 742
 743     result = GetTempFileNameA(windowsdir, "abc", 2, out);
 744     ok(result != 0, "GetTempFileNameA: error %ld\n", GetLastError());
 745     expected[0] = '\0';
 746     strcat(expected, windowsdir);
 747     strcat(expected, "abc2.tmp");
 748     ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
 749        out, expected);
 750 }
 751
 752 static void test_DeleteFileA( void )
 753 {
 754     BOOL ret;
 755
 756     ret = DeleteFileA(NULL);
 757     ok(!ret && (GetLastError() == ERROR_INVALID_PARAMETER ||
 758                 GetLastError() == ERROR_PATH_NOT_FOUND),
 759        "DeleteFileA(NULL) returned ret=%d error=%ld\n",ret,GetLastError());
 760
 761     ret = DeleteFileA("");
 762     ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND ||
 763                 GetLastError() == ERROR_BAD_PATHNAME),
 764        "DeleteFileA(\"\") returned ret=%d error=%ld\n",ret,GetLastError());
 765
 766     ret = DeleteFileA("nul");
 767     ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
 768                 GetLastError() == ERROR_INVALID_PARAMETER ||
 769                 GetLastError() == ERROR_ACCESS_DENIED ||
 770                 GetLastError() == ERROR_INVALID_FUNCTION),
 771        "DeleteFileA(\"nul\") returned ret=%d error=%ld\n",ret,GetLastError());
 772 }
 773
 774 static void test_DeleteFileW( void )
 775 {
 776     BOOL ret;
 777     static const WCHAR emptyW[]={'\0'};
 778
 779     ret = DeleteFileW(NULL);
 780     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 781         return;
 782     ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
 783        "DeleteFileW(NULL) returned ret=%d error=%ld\n",ret,GetLastError());
 784
 785     ret = DeleteFileW(emptyW);
 786     ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
 787        "DeleteFileW(\"\") returned ret=%d error=%ld\n",ret,GetLastError());
 788 }
 789
 790 #define IsDotDir(x)     ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
 791
 792 static void test_MoveFileA(void)
 793 {
 794     char tempdir[MAX_PATH];
 795     char source[MAX_PATH], dest[MAX_PATH];
 796     static const char prefix[] = "pfx";
 797     DWORD ret;
 798
 799     ret = GetTempPathA(MAX_PATH, tempdir);
 800     ok(ret != 0, "GetTempPathA error %ld\n", GetLastError());
 801     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 802
 803     ret = GetTempFileNameA(tempdir, prefix, 0, source);
 804     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
 805
 806     ret = GetTempFileNameA(tempdir, prefix, 0, dest);
 807     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
 808
 809     ret = MoveFileA(source, dest);
 810     ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
 811        "MoveFileA: unexpected error %ld\n", GetLastError());
 812
 813     ret = DeleteFileA(dest);
 814     ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 815
 816     ret = MoveFileA(source, dest);
 817     ok(ret, "MoveFileA: failed, error %ld\n", GetLastError());
 818
 819     lstrcatA(tempdir, "Remove Me");
 820     ret = CreateDirectoryA(tempdir, NULL);
 821     ok(ret == TRUE, "CreateDirectoryA failed\n");
 822
 823     lstrcpyA(source, dest);
 824     lstrcpyA(dest, tempdir);
 825     lstrcatA(dest, "\\wild?.*");
 826     /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
 827     ret = MoveFileA(source, dest);
 828     ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
 829     ok(GetLastError() == ERROR_INVALID_NAME || /* NT */
 830        GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x */
 831        "MoveFileA: with wildcards, unexpected error %ld\n", GetLastError());
 832     if (ret || (GetLastError() != ERROR_INVALID_NAME))
 833     {
 834         WIN32_FIND_DATAA fd;
 835         char temppath[MAX_PATH];
 836         HANDLE hFind;
 837
 838         lstrcpyA(temppath, tempdir);
 839         lstrcatA(temppath, "\\*.*");
 840         hFind = FindFirstFileA(temppath, &fd);
 841         if (INVALID_HANDLE_VALUE != hFind)
 842         {
 843           LPSTR lpName;
 844           do
 845           {
 846             lpName = fd.cAlternateFileName;
 847             if (!lpName[0])
 848               lpName = fd.cFileName;
 849             ok(IsDotDir(lpName), "MoveFileA: wildcards file created!\n");
 850           }
 851           while (FindNextFileA(hFind, &fd));
 852           FindClose(hFind);
 853         }
 854     }
 855     ret = DeleteFileA(source);
 856     ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 857     ret = DeleteFileA(dest);
 858     ok(!ret, "DeleteFileA: error %ld\n", GetLastError());
 859     ret = RemoveDirectoryA(tempdir);
 860     ok(ret, "DeleteDirectoryA: error %ld\n", GetLastError());
 861 }
 862
 863 static void test_MoveFileW(void)
 864 {
 865     WCHAR temp_path[MAX_PATH];
 866     WCHAR source[MAX_PATH], dest[MAX_PATH];
 867     static const WCHAR prefix[] = {'p','f','x',0};
 868     DWORD ret;
 869
 870     ret = GetTempPathW(MAX_PATH, temp_path);
 871     if (ret==0 && GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
 872         return;
 873     ok(ret != 0, "GetTempPathW error %ld\n", GetLastError());
 874     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
 875
 876     ret = GetTempFileNameW(temp_path, prefix, 0, source);
 877     ok(ret != 0, "GetTempFileNameW error %ld\n", GetLastError());
 878
 879     ret = GetTempFileNameW(temp_path, prefix, 0, dest);
 880     ok(ret != 0, "GetTempFileNameW error %ld\n", GetLastError());
 881
 882     ret = MoveFileW(source, dest);
 883     ok(!ret && GetLastError() == ERROR_ALREADY_EXISTS,
 884        "CopyFileW: unexpected error %ld\n", GetLastError());
 885
 886     ret = DeleteFileW(source);
 887     ok(ret, "DeleteFileW: error %ld\n", GetLastError());
 888     ret = DeleteFileW(dest);
 889     ok(ret, "DeleteFileW: error %ld\n", GetLastError());
 890 }
 891
 892 #define PATTERN_OFFSET 0x10
 893
 894 static void test_offset_in_overlapped_structure(void)
 895 {
 896     HANDLE hFile;
 897     OVERLAPPED ov;
 898     DWORD done;
 899     BOOL rc;
 900     BYTE buf[256], pattern[] = "TeSt";
 901     UINT i;
 902     char temp_path[MAX_PATH], temp_fname[MAX_PATH];
 903     BOOL ret;
 904
 905     ret =GetTempPathA(MAX_PATH, temp_path);
 906     ok( ret, "GetTempPathA error %ld\n", GetLastError());
 907     ret =GetTempFileNameA(temp_path, "pfx", 0, temp_fname);
 908     ok( ret, "GetTempFileNameA error %ld\n", GetLastError());
 909
 910     /*** Write File *****************************************************/
 911
 912     hFile = CreateFileA(temp_fname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 913     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %ld\n", GetLastError());
 914
 915     for(i = 0; i < sizeof(buf); i++) buf[i] = i;
 916     ret = WriteFile(hFile, buf, sizeof(buf), &done, NULL);
 917     ok( ret, "WriteFile error %ld\n", GetLastError());
 918     ok(done == sizeof(buf), "expected number of bytes written %lu\n", done);
 919
 920     memset(&ov, 0, sizeof(ov));
 921     S(U(ov)).Offset = PATTERN_OFFSET;
 922     S(U(ov)).OffsetHigh = 0;
 923     rc=WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
 924     /* Win 9x does not support the overlapped I/O on files */
 925     if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
 926         ok(rc, "WriteFile error %ld\n", GetLastError());
 927         ok(done == sizeof(pattern), "expected number of bytes written %lu\n", done);
 928         /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
 929         ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)),
 930            "expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern));
 931
 932         S(U(ov)).Offset = sizeof(buf) * 2;
 933         S(U(ov)).OffsetHigh = 0;
 934         ret = WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
 935         ok( ret, "WriteFile error %ld\n", GetLastError());
 936         ok(done == sizeof(pattern), "expected number of bytes written %lu\n", done);
 937         /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
 938         ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (sizeof(buf) * 2 + sizeof(pattern)),
 939            "expected file offset %d\n", sizeof(buf) * 2 + sizeof(pattern));
 940     }
 941
 942     CloseHandle(hFile);
 943
 944     /*** Read File *****************************************************/
 945
 946     hFile = CreateFileA(temp_fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
 947     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %ld\n", GetLastError());
 948
 949     memset(buf, 0, sizeof(buf));
 950     memset(&ov, 0, sizeof(ov));
 951     S(U(ov)).Offset = PATTERN_OFFSET;
 952     S(U(ov)).OffsetHigh = 0;
 953     rc=ReadFile(hFile, buf, sizeof(pattern), &done, &ov);
 954     /* Win 9x does not support the overlapped I/O on files */
 955     if (rc || GetLastError()!=ERROR_INVALID_PARAMETER) {
 956         ok(rc, "ReadFile error %ld\n", GetLastError());
 957         ok(done == sizeof(pattern), "expected number of bytes read %lu\n", done);
 958         /*trace("Current offset = %04lx\n", SetFilePointer(hFile, 0, NULL, FILE_CURRENT));*/
 959         ok(SetFilePointer(hFile, 0, NULL, FILE_CURRENT) == (PATTERN_OFFSET + sizeof(pattern)),
 960            "expected file offset %d\n", PATTERN_OFFSET + sizeof(pattern));
 961         ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
 962     }
 963
 964     CloseHandle(hFile);
 965
 966     ret = DeleteFileA(temp_fname);
 967     ok( ret, "DeleteFileA error %ld\n", GetLastError());
 968 }
 969
 970 static void test_LockFile(void)
 971 {
 972     HANDLE handle;
 973     DWORD written;
 974     OVERLAPPED overlapped;
 975     int limited_LockFile;
 976     int limited_UnLockFile;
 977     int lockfileex_capable;
 978
 979     handle = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE,
 980                           FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 981                           CREATE_ALWAYS, 0, 0 );
 982     if (handle == INVALID_HANDLE_VALUE)
 983     {
 984         ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
 985         return;
 986     }
 987     ok( WriteFile( handle, sillytext, strlen(sillytext), &written, NULL ), "write failed\n" );
 988
 989     ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
 990     ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
 991
 992     limited_UnLockFile = 0;
 993     if (UnlockFile( handle, 0, 0, 0, 0 ))
 994     {
 995         limited_UnLockFile = 1;
 996     }
 997
 998     ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
 999     /* overlapping locks must fail */
1000     ok( !LockFile( handle, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
1001     ok( !LockFile( handle, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
1002     /* non-overlapping locks must succeed */
1003     ok( LockFile( handle, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
1004
1005     ok( !UnlockFile( handle, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
1006     ok( UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
1007     ok( !UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
1008     ok( UnlockFile( handle, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
1009
1010     S(U(overlapped)).Offset = 100;
1011     S(U(overlapped)).OffsetHigh = 0;
1012     overlapped.hEvent = 0;
1013
1014     lockfileex_capable = dll_capable("kernel32", "LockFileEx");
1015     if (lockfileex_capable)
1016     {
1017         /* Test for broken LockFileEx a la Windows 95 OSR2. */
1018         if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
1019         {
1020             /* LockFileEx is probably OK, test it more. */
1021             ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
1022                 "LockFileEx 100,100 failed\n" );
1023         }
1024     }
1025
1026     /* overlapping shared locks are OK */
1027     S(U(overlapped)).Offset = 150;
1028     limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
1029
1030     /* but exclusive is not */
1031     if (lockfileex_capable)
1032     {
1033         ok( !LockFileEx( handle, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
1034                          0, 50, 0, &overlapped ),
1035                          "LockFileEx exclusive 150,50 succeeded\n" );
1036         if (dll_capable("kernel32.dll", "UnlockFileEx"))
1037         {
1038             if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
1039             { /* UnLockFile is capable. */
1040                 S(U(overlapped)).Offset = 100;
1041                 ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
1042                     "UnlockFileEx 150,100 again succeeded\n" );
1043             }
1044         }
1045     }
1046
1047     ok( LockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "LockFile failed\n" );
1048     ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
1049     ok( !LockFile( handle, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
1050     ok( UnlockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
1051
1052     /* wrap-around lock should not do anything */
1053     /* (but still succeeds on NT4 so we don't check result) */
1054     LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
1055
1056     limited_LockFile = 0;
1057     if (!LockFile( handle, ~0, ~0, 1, 0 ))
1058     {
1059         limited_LockFile = 1;
1060     }
1061
1062     limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
1063
1064     /* zero-byte lock */
1065     ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
1066     limited_LockFile || ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
1067     ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
1068     limited_LockFile || ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
1069
1070     ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
1071     !ok( UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 failed\n" );
1072
1073     ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
1074
1075     CloseHandle( handle );
1076     DeleteFileA( filename );
1077 }
1078
1079 static inline int is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2 )
1080 {
1081     if (!access1 || !access2) return 1;
1082     if ((access1 & GENERIC_READ) && !(sharing2 & FILE_SHARE_READ)) return 0;
1083     if ((access1 & GENERIC_WRITE) && !(sharing2 & FILE_SHARE_WRITE)) return 0;
1084     if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return 0;
1085     if ((access2 & GENERIC_READ) && !(sharing1 & FILE_SHARE_READ)) return 0;
1086     if ((access2 & GENERIC_WRITE) && !(sharing1 & FILE_SHARE_WRITE)) return 0;
1087     if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return 0;
1088     return 1;
1089 }
1090
1091 static void test_file_sharing(void)
1092 {
1093     static const DWORD access_modes[] =
1094         { 0, GENERIC_READ, GENERIC_WRITE, GENERIC_READ|GENERIC_WRITE,
1095           DELETE, GENERIC_READ|DELETE, GENERIC_WRITE|DELETE, GENERIC_READ|GENERIC_WRITE|DELETE };
1096     static const DWORD sharing_modes[] =
1097         { 0, FILE_SHARE_READ,
1098           FILE_SHARE_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1099           FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_DELETE,
1100           FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE };
1101     int a1, s1, a2, s2;
1102     int ret;
1103     HANDLE h, h2;
1104
1105     /* make sure the file exists */
1106     h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1107     if (h == INVALID_HANDLE_VALUE)
1108     {
1109         ok(0, "couldn't create file \"%s\" (err=%ld)\n", filename, GetLastError());
1110         return;
1111     }
1112     CloseHandle( h );
1113
1114     for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
1115     {
1116         for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
1117         {
1118             h = CreateFileA( filename, access_modes[a1], sharing_modes[s1],
1119                              NULL, OPEN_EXISTING, 0, 0 );
1120             if (h == INVALID_HANDLE_VALUE)
1121             {
1122                 ok(0,"couldn't create file \"%s\" (err=%ld)\n",filename,GetLastError());
1123                 return;
1124             }
1125             for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
1126             {
1127                 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
1128                 {
1129                     SetLastError(0xdeadbeef);
1130                     h2 = CreateFileA( filename, access_modes[a2], sharing_modes[s2],
1131                                       NULL, OPEN_EXISTING, 0, 0 );
1132                     if (is_sharing_compatible( access_modes[a1], sharing_modes[s1],
1133                                                access_modes[a2], sharing_modes[s2] ))
1134                     {
1135                         ret = GetLastError();
1136                         ok( ERROR_SHARING_VIOLATION == ret || 0 == ret,
1137                             "Windows 95 sets GetLastError() = ERROR_SHARING_VIOLATION and\n"
1138                             "  Windows XP GetLastError() = 0, but now it is %d.\n"
1139                             "  indexes = %d, %d, %d, %d\n"
1140                             "  modes   =\n  %lx/%lx/%lx/%lx\n",
1141                             ret,
1142                             a1, s1, a2, s2,
1143                             access_modes[a1], sharing_modes[s1],
1144                             access_modes[a2], sharing_modes[s2]
1145                             );
1146                     }
1147                     else
1148                     {
1149                         ok( h2 == INVALID_HANDLE_VALUE,
1150                             "open succeeded for modes %lx/%lx/%lx/%lx\n",
1151                             access_modes[a1], sharing_modes[s1],
1152                             access_modes[a2], sharing_modes[s2] );
1153                         if (h2 == INVALID_HANDLE_VALUE)
1154                             ok( GetLastError() == ERROR_SHARING_VIOLATION,
1155                                 "wrong error code %ld\n", GetLastError() );
1156                     }
1157                     if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
1158                 }
1159             }
1160             CloseHandle( h );
1161         }
1162     }
1163
1164     SetLastError(0xdeadbeef);
1165     h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, 0 );
1166     ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %ld\n", GetLastError() );
1167
1168     SetLastError(0xdeadbeef);
1169     h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1170     ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
1171     ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %ld\n", GetLastError() );
1172
1173     h2 = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
1174     ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %ld\n", GetLastError() );
1175
1176     CloseHandle(h);
1177     CloseHandle(h2);
1178
1179     DeleteFileA( filename );
1180 }
1181
1182 static char get_windows_drive(void)
1183 {
1184     char windowsdir[MAX_PATH];
1185     GetWindowsDirectory(windowsdir, sizeof(windowsdir));
1186     return windowsdir[0];
1187 }
1188
1189 static void test_FindFirstFileA(void)
1190 {
1191     HANDLE handle;
1192     WIN32_FIND_DATAA search_results;
1193     int err;
1194     char buffer[5] = "C:\\";
1195
1196     /* try FindFirstFileA on "C:\" */
1197     buffer[0] = get_windows_drive();
1198     handle = FindFirstFileA(buffer,&search_results);
1199     err = GetLastError();
1200     ok ( handle == INVALID_HANDLE_VALUE , "FindFirstFile on root directory should Fail\n");
1201     if (handle == INVALID_HANDLE_VALUE)
1202       ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err);
1203
1204     /* try FindFirstFileA on "C:\*" */
1205     strcat(buffer, "*");
1206     handle = FindFirstFileA(buffer,&search_results);
1207     ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer );
1208     ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
1209 }
1210
1211 static void test_FindNextFileA(void)
1212 {
1213     HANDLE handle;
1214     WIN32_FIND_DATAA search_results;
1215     int err;
1216     char buffer[5] = "C:\\*";
1217
1218     buffer[0] = get_windows_drive();
1219     handle = FindFirstFileA(buffer,&search_results);
1220     ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
1221     while (FindNextFile(handle, &search_results))
1222     {
1223         /* get to the end of the files */
1224     }
1225     ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
1226     err = GetLastError();
1227     ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
1228 }
1229
1230 static int test_Mapfile_createtemp(HANDLE *handle)
1231 {
1232     SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL);
1233     DeleteFile(filename);
1234     *handle = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, 0,
1235                          CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1236     if (*handle != INVALID_HANDLE_VALUE) {
1237
1238         return 1;
1239     }
1240
1241     return 0;
1242 }
1243
1244 static void test_MapFile(void)
1245 {
1246     HANDLE handle;
1247     HANDLE hmap;
1248
1249     ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
1250
1251     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
1252     ok( hmap != NULL, "mapping should work, I named it!\n" );
1253
1254     ok( CloseHandle( hmap ), "can't close mapping handle\n");
1255
1256     /* We have to close file before we try new stuff with mapping again.
1257        Else we would always succeed on XP or block descriptors on 95. */
1258     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
1259     ok( hmap != NULL, "We should still be able to map!\n" );
1260     ok( CloseHandle( hmap ), "can't close mapping handle\n");
1261     ok( CloseHandle( handle ), "can't close file handle\n");
1262     handle = NULL;
1263
1264     ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
1265
1266     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0, 0, NULL );
1267     ok( hmap == NULL, "mapped zero size file\n");
1268     ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
1269
1270     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0, NULL );
1271     ok( hmap == NULL, "mapping should fail\n");
1272     /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1273
1274     hmap = CreateFileMapping( handle, NULL, PAGE_READWRITE, 0x1000, 0x10000, NULL );
1275     ok( hmap == NULL, "mapping should fail\n");
1276     /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
1277
1278     /* On XP you can now map again, on Win 95 you cannot. */
1279
1280     ok( CloseHandle( handle ), "can't close file handle\n");
1281     ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
1282 }
1283
1284 static void test_GetFileType(void)
1285 {
1286     DWORD type;
1287     HANDLE h = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
1288     ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
1289     type = GetFileType(h);
1290     ok( type == FILE_TYPE_DISK, "expected type disk got %ld\n", type );
1291     CloseHandle( h );
1292     h = CreateFileA( "nul", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
1293     ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
1294     type = GetFileType(h);
1295     ok( type == FILE_TYPE_CHAR, "expected type char for nul got %ld\n", type );
1296     CloseHandle( h );
1297     DeleteFileA( filename );
1298 }
1299
1300 static int completion_count;
1301
1302 static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
1303 {
1304 /*      printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
1305         ReleaseSemaphore(ovl->hEvent, 1, NULL);
1306         completion_count++;
1307 }
1308
1309 static void test_async_file_errors(void)
1310 {
1311     char szFile[MAX_PATH];
1312     HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
1313     HANDLE hFile;
1314     LPVOID lpBuffer = HeapAlloc(GetProcessHeap(), 0, 4096);
1315     OVERLAPPED ovl;
1316     S(U(ovl)).Offset = 0;
1317     S(U(ovl)).OffsetHigh = 0;
1318     ovl.hEvent = hSem;
1319     completion_count = 0;
1320     szFile[0] = '\0';
1321     GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
1322     strcat(szFile, "\\win.ini");
1323     hFile = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
1324     ok(hFile != NULL, "CreateFileA(%s ...) failed\n", szFile);
1325     while (TRUE)
1326     {
1327         BOOL res;
1328         while (WaitForSingleObjectEx(hSem, INFINITE, TRUE) == WAIT_IO_COMPLETION)
1329             ;
1330         res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
1331         /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
1332         if (!res)
1333             break;
1334         S(U(ovl)).Offset += 4096;
1335         /* i/o completion routine only called if ReadFileEx returned success.
1336          * we only care about violations of this rule so undo what should have
1337          * been done */
1338         completion_count--;
1339     }
1340     ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
1341     /*printf("Error = %ld\n", GetLastError());*/
1342 }
1343
1344 static void test_read_write(void)
1345 {
1346     DWORD bytes, ret;
1347     HANDLE hFile;
1348     char temp_path[MAX_PATH];
1349     char filename[MAX_PATH];
1350     static const char prefix[] = "pfx";
1351
1352     ret = GetTempPathA(MAX_PATH, temp_path);
1353     ok(ret != 0, "GetTempPathA error %ld\n", GetLastError());
1354     ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1355
1356     ret = GetTempFileNameA(temp_path, prefix, 0, filename);
1357     ok(ret != 0, "GetTempFileNameA error %ld\n", GetLastError());
1358
1359     hFile = CreateFileA(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
1360                         CREATE_ALWAYS, FILE_FLAG_RANDOM_ACCESS, 0);
1361     ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %ld\n", GetLastError());
1362
1363     SetLastError(12345678);
1364     bytes = 12345678;
1365     ret = WriteFile(hFile, NULL, 0, &bytes, NULL);
1366     ok(ret && GetLastError() == 12345678,
1367         "ret = %ld, error %ld\n", ret, GetLastError());
1368     ok(!bytes, "bytes = %ld\n", bytes);
1369
1370     SetLastError(12345678);
1371     bytes = 12345678;
1372     ret = WriteFile(hFile, NULL, 10, &bytes, NULL);
1373     ok((!ret && GetLastError() == ERROR_INVALID_USER_BUFFER) || /* Win2k */
1374         (ret && GetLastError() == 12345678), /* Win9x */
1375         "ret = %ld, error %ld\n", ret, GetLastError());
1376     ok(!bytes || /* Win2k */
1377         bytes == 10, /* Win9x */
1378         "bytes = %ld\n", bytes);
1379
1380     /* make sure the file contains data */
1381     WriteFile(hFile, "this is the test data", 21, &bytes, NULL);
1382     SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
1383
1384     SetLastError(12345678);
1385     bytes = 12345678;
1386     ret = ReadFile(hFile, NULL, 0, &bytes, NULL);
1387     ok(ret && GetLastError() == 12345678,
1388         "ret = %ld, error %ld\n", ret, GetLastError());
1389     ok(!bytes, "bytes = %ld\n", bytes);
1390
1391     SetLastError(12345678);
1392     bytes = 12345678;
1393     ret = ReadFile(hFile, NULL, 10, &bytes, NULL);
1394     ok(!ret && (GetLastError() == ERROR_NOACCESS || /* Win2k */
1395                 GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
1396         "ret = %ld, error %ld\n", ret, GetLastError());
1397     ok(!bytes, "bytes = %ld\n", bytes);
1398
1399     ret = CloseHandle(hFile);
1400     ok( ret, "CloseHandle: error %ld\n", GetLastError());
1401     ret = DeleteFileA(filename);
1402     ok( ret, "DeleteFileA: error %ld\n", GetLastError());
1403 }
1404
1405 static void test_OpenFile_exists(void)
1406 {
1407     HFILE hFile;
1408     OFSTRUCT ofs;
1409
1410     static const char *file = "\\winver.exe";
1411     char buff[MAX_PATH];
1412     UINT length;
1413
1414     length = GetSystemDirectoryA(buff, MAX_PATH);
1415
1416     if ((length + lstrlen(file) < MAX_PATH))
1417     {
1418         lstrcat(buff, file);
1419
1420         hFile = OpenFile(buff, &ofs, OF_EXIST);
1421         ok( hFile == TRUE, "%s not found : %ld\n", buff, GetLastError());
1422     }
1423
1424     hFile = OpenFile(".\\foo-bar-foo.baz", &ofs, OF_EXIST);
1425     ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %ld\n", GetLastError());
1426 }
1427
1428
1429 START_TEST(file)
1430 {
1431     test__hread(  );
1432     test__hwrite(  );
1433     test__lclose(  );
1434     test__lcreat(  );
1435     test__llseek(  );
1436     test__llopen(  );
1437     test__lread(  );
1438     test__lwrite(  );
1439     test_GetTempFileNameA();
1440     test_CopyFileA();
1441     test_CopyFileW();
1442     test_CreateFileA();
1443     test_CreateFileW();
1444     test_DeleteFileA();
1445     test_DeleteFileW();
1446     test_MoveFileA();
1447     test_MoveFileW();
1448     test_FindFirstFileA();
1449     test_FindNextFileA();
1450     test_LockFile();
1451     test_file_sharing();
1452     test_offset_in_overlapped_structure();
1453     test_MapFile();
1454     test_GetFileType();
1455     test_async_file_errors();
1456     test_read_write();
1457     test_OpenFile_exists();
1458 }