dlls/lz32/tests/lzexpand_main.c

   1 /*
   2  * Unit test suite for lz32 functions
   3  *
   4  * Copyright 2004 Evan Parry, Daniel Kegel
   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 #include <stdarg.h>
  22 #include <windef.h>
  23 #include <winbase.h>
  24 #include <stdlib.h>
  25 #include <winerror.h>
  26 #include <lzexpand.h>
  27
  28 #include "wine/test.h"
  29
  30 /* Compressed file names end with underscore. */
  31 static char filename [] = "testfile.xxx";
  32 static char filename_[] = "testfile.xx_";
  33 static WCHAR filenameW [] = {'t','e','s','t','f','i','l','e','.','x','x','x',0};
  34 static WCHAR filenameW_[] = {'t','e','s','t','f','i','l','e','.','x','x','_',0};
  35
  36 static char dotless [] = "dotless";
  37 static char dotless_[] = "dotless._";
  38 static WCHAR dotlessW [] = {'d','o','t','l','e','s','s', 0};
  39 static WCHAR dotlessW_[] = {'d','o','t','l','e','s','s','.','_', 0};
  40
  41 static char extless [] = "extless.";
  42 static char extless_[] = "extless._";
  43 static WCHAR extlessW [] = {'e','x','t','l','e','s','s','.', 0};
  44 static WCHAR extlessW_[] = {'e','x','t','l','e','s','s','.','_', 0};
  45
  46 static char _terminated [] = "_terminated.xxxx_";
  47 static char _terminated_[] = "_terminated.xxxx_";
  48 static WCHAR _terminatedW [] = {'_','t','e','r','m','i','n','a','t','e','d','.','x','x','x','x','_', 0};
  49 static WCHAR _terminatedW_[] = {'_','t','e','r','m','i','n','a','t','e','d','.','x','x','x','x','_', 0};
  50
  51 static char filename2[] = "testfile.yyy";
  52
  53 /* This is the hex string representation of the file created by compressing
  54    a simple text file with the contents "This is a test file."
  55
  56    The file was created using COMPRESS.EXE from the Windows Server 2003
  57    Resource Kit from Microsoft.  The resource kit was retrieved from the
  58    following URL:
  59
  60    http://www.microsoft.com/downloads/details.aspx?FamilyID=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en
  61  */
  62 static const unsigned char compressed_file[] =
  63   {0x53,0x5A,0x44,0x44,0x88,0xF0,0x27,0x33,0x41,
  64    0x74,0x75,0x14,0x00,0x00,0xDF,0x54,0x68,0x69,
  65    0x73,0x20,0xF2,0xF0,0x61,0x20,0xFF,0x74,0x65,
  66    0x73,0x74,0x20,0x66,0x69,0x6C,0x03,0x65,0x2E};
  67 static const DWORD compressed_file_size = sizeof(compressed_file);
  68
  69 static const char uncompressed_data[] = "This is a test file.";
  70 static const DWORD uncompressed_data_size = sizeof(uncompressed_data) - 1;
  71
  72 static char *buf;
  73
  74 static void full_file_path_name_in_a_CWD(const char *src, char *dst, BOOL expect_short)
  75 {
  76   DWORD retval;
  77   char shortname[MAX_PATH];
  78
  79   retval = GetCurrentDirectoryA(MAX_PATH, dst);
  80   ok(retval > 0, "GetCurrentDirectoryA returned %ld, GLE=0x%lx\n",
  81      retval, GetLastError());
  82   lstrcatA(dst, "\\");
  83   lstrcatA(dst, src);
  84   if(expect_short)
  85   {
  86     memcpy(shortname, dst, MAX_PATH);
  87     GetShortPathName(shortname, dst, MAX_PATH-1);
  88   }
  89 }
  90
  91 static void create_file(char *fname)
  92 {
  93   INT file;
  94   OFSTRUCT ofs;
  95   DWORD retval;
  96
  97   file = LZOpenFileA(fname, &ofs, OF_CREATE);
  98   ok(file >= 0, "LZOpenFileA failed on creation\n");
  99   LZClose(file);
 100   retval = GetFileAttributesA(fname);
 101   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA('%s'): error %ld\n", ofs.szPathName, GetLastError());
 102 }
 103
 104 static void delete_file(char *fname)
 105 {
 106   INT file;
 107   OFSTRUCT ofs;
 108   DWORD retval;
 109
 110   file = LZOpenFileA(fname, &ofs, OF_DELETE);
 111   ok(file >= 0, "LZOpenFileA failed on delete\n");
 112   LZClose(file);
 113   retval = GetFileAttributesA(fname);
 114   ok(retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file ('%s')\n", ofs.szPathName);
 115 }
 116
 117 static void test_LZOpenFileA_existing_compressed(void)
 118 {
 119   OFSTRUCT test;
 120   INT file;
 121   char expected[MAX_PATH];
 122   char short_expected[MAX_PATH];
 123   char filled_0xA5[OFS_MAXPATHNAME];
 124
 125   /* Try to open existing compressed files: */
 126   create_file(filename_);
 127   create_file(dotless_);
 128   create_file(extless_);
 129   create_file(_terminated_);
 130
 131   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 132   memset(&test, 0xA5, sizeof(test));
 133   full_file_path_name_in_a_CWD(filename_, expected, FALSE);
 134   SetLastError(0xfaceabee);
 135
 136   /* a, using 8.3-conformant file name. */
 137   file = LZOpenFileA(filename, &test, OF_EXIST);
 138   /* If the file "foo.xxx" does not exist, LZOpenFileA should then
 139      check for the file "foo.xx_" and open that -- at least on some
 140      operating systems.  Doesn't seem to on my copy of Win98.
 141    */
 142   if(file != LZERROR_BADINHANDLE) {
 143     ok(test.cBytes == sizeof(OFSTRUCT),
 144        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 145     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 146        test.nErrCode);
 147     ok(lstrcmpA(test.szPathName, expected) == 0,
 148        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 149        test.szPathName, expected);
 150     LZClose(file);
 151   } else { /* Win9x */
 152     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 153        "GetLastError() returns %ld\n", GetLastError());
 154     ok(test.cBytes == 0xA5,
 155        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 156     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 157        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 158     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 159        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 160        test.szPathName, filled_0xA5);
 161   }
 162
 163   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 164   memset(&test, 0xA5, sizeof(test));
 165   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 166   SetLastError(0xfaceabee);
 167
 168   /* b, using dotless file name. */
 169   file = LZOpenFileA(dotless, &test, OF_EXIST);
 170   if(file != LZERROR_BADINHANDLE) {
 171     ok(test.cBytes == sizeof(OFSTRUCT),
 172        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 173     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 174        test.nErrCode);
 175     ok(lstrcmpA(test.szPathName, expected) == 0,
 176        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 177        test.szPathName, expected);
 178     LZClose(file);
 179   } else { /* Win9x */
 180     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 181        "GetLastError() returns %ld\n", GetLastError());
 182     todo_wine
 183     ok(test.cBytes == 0xA5,
 184        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 185     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 186        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 187     todo_wine
 188     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 189        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 190        test.szPathName, filled_0xA5);
 191   }
 192
 193   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 194   memset(&test, 0xA5, sizeof(test));
 195   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 196   SetLastError(0xfaceabee);
 197
 198   /* c, using extensionless file name. */
 199   file = LZOpenFileA(extless, &test, OF_EXIST);
 200   if(file != LZERROR_BADINHANDLE) {
 201     ok(test.cBytes == sizeof(OFSTRUCT),
 202        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 203     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 204        test.nErrCode);
 205     ok(lstrcmpA(test.szPathName, expected) == 0,
 206        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 207        test.szPathName, expected);
 208     LZClose(file);
 209   } else { /* Win9x */
 210     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 211        "GetLastError() returns %ld\n", GetLastError());
 212     ok(test.cBytes == 0xA5,
 213        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 214     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 215        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 216     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 217        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 218        test.szPathName, filled_0xA5);
 219   }
 220
 221   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 222   memset(&test, 0xA5, sizeof(test));
 223   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 224   full_file_path_name_in_a_CWD(_terminated_, short_expected, TRUE);
 225
 226   /* d, using underscore-terminated file name. */
 227   file = LZOpenFileA(_terminated, &test, OF_EXIST);
 228   ok(file >= 0, "LZOpenFileA failed on switching to a compressed file name\n");
 229   ok(test.cBytes == sizeof(OFSTRUCT),
 230      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 231   ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 232      test.nErrCode);
 233   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 234      lstrcmpA(test.szPathName, short_expected) == 0, /* Win9x */
 235      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 236      test.szPathName, expected, short_expected);
 237   LZClose(file);
 238
 239   delete_file(filename_);
 240   delete_file(dotless_);
 241   delete_file(extless_);
 242   delete_file(_terminated_);
 243 }
 244
 245 static void test_LZOpenFileA_nonexisting_compressed(void)
 246 {
 247   OFSTRUCT test;
 248   INT file;
 249   char expected[MAX_PATH];
 250   char filled_0xA5[OFS_MAXPATHNAME];
 251
 252   /* Try to open nonexisting compressed files: */
 253   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 254   memset(&test, 0xA5, sizeof(test));
 255   full_file_path_name_in_a_CWD(filename_, expected, FALSE);
 256   SetLastError(0xfaceabee);
 257
 258   /* a, using 8.3-conformant file name. */
 259   file = LZOpenFileA(filename, &test, OF_EXIST);
 260   /* If the file "foo.xxx" does not exist, LZOpenFileA should then
 261      check for the file "foo.xx_" and open that -- at least on some
 262      operating systems.  Doesn't seem to on my copy of Win98.
 263    */
 264   ok(file == LZERROR_BADINHANDLE,
 265      "LZOpenFileA succeeded on nonexistent file\n");
 266   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 267      "GetLastError() returns %ld\n", GetLastError());
 268   todo_wine
 269   ok(test.cBytes == 0xA5,
 270      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 271   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 272      "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 273   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 274      strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0, /* Win9x */
 275      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 276      test.szPathName, expected, filled_0xA5);
 277
 278   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 279   memset(&test, 0xA5, sizeof(test));
 280   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 281   SetLastError(0xfaceabee);
 282
 283   /* b, using dotless file name. */
 284   file = LZOpenFileA(dotless, &test, OF_EXIST);
 285   ok(file == LZERROR_BADINHANDLE,
 286      "LZOpenFileA succeeded on nonexistent file\n");
 287   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 288      "GetLastError() returns %ld\n", GetLastError());
 289   todo_wine
 290   ok(test.cBytes == 0xA5,
 291      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 292   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 293      "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 294   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 295      strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0, /* Win9x */
 296      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 297      test.szPathName, expected, filled_0xA5);
 298
 299   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 300   memset(&test, 0xA5, sizeof(test));
 301   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 302   SetLastError(0xfaceabee);
 303
 304   /* c, using extensionless file name. */
 305   file = LZOpenFileA(extless, &test, OF_EXIST);
 306   ok(file == LZERROR_BADINHANDLE,
 307      "LZOpenFileA succeeded on nonexistent file\n");
 308   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 309      "GetLastError() returns %ld\n", GetLastError());
 310   todo_wine
 311   ok(test.cBytes == 0xA5,
 312      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 313   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 314      "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 315   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 316      strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0, /* Win9x */
 317      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 318      test.szPathName, expected, filled_0xA5);
 319
 320   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 321   memset(&test, 0xA5, sizeof(test));
 322   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 323   SetLastError(0xfaceabee);
 324
 325   /* d, using underscore-terminated file name. */
 326   file = LZOpenFileA(_terminated, &test, OF_EXIST);
 327   ok(file == LZERROR_BADINHANDLE,
 328      "LZOpenFileA succeeded on nonexistent file\n");
 329   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 330      "GetLastError() returns %ld\n", GetLastError());
 331   todo_wine
 332   ok(test.cBytes == 0xA5,
 333      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 334   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 335      "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 336   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 337      strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0, /* Win9x */
 338      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 339      test.szPathName, expected, filled_0xA5);
 340 }
 341
 342 static void test_LZOpenFileA(void)
 343 {
 344   OFSTRUCT test;
 345   DWORD retval;
 346   INT file;
 347   static char badfilename_[] = "badfilename_";
 348
 349   SetLastError(0xfaceabee);
 350   /* Check for nonexistent file. */
 351   file = LZOpenFileA(badfilename_, &test, OF_READ);
 352   ok(file == LZERROR_BADINHANDLE,
 353      "LZOpenFileA succeeded on nonexistent file\n");
 354   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 355      "GetLastError() returns %ld\n", GetLastError());
 356   LZClose(file);
 357
 358   /* Create an empty file. */
 359   file = LZOpenFileA(filename_, &test, OF_CREATE);
 360   ok(file >= 0, "LZOpenFileA failed on creation\n");
 361   LZClose(file);
 362   retval = GetFileAttributesA(filename_);
 363   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %ld\n",
 364      GetLastError());
 365
 366   /* Check various opening options. */
 367   file = LZOpenFileA(filename_, &test, OF_READ);
 368   ok(file >= 0, "LZOpenFileA failed on read\n");
 369   LZClose(file);
 370   file = LZOpenFileA(filename_, &test, OF_WRITE);
 371   ok(file >= 0, "LZOpenFileA failed on write\n");
 372   LZClose(file);
 373   file = LZOpenFileA(filename_, &test, OF_READWRITE);
 374   ok(file >= 0, "LZOpenFileA failed on read/write\n");
 375   LZClose(file);
 376   file = LZOpenFileA(filename_, &test, OF_EXIST);
 377   ok(file >= 0, "LZOpenFileA failed on read/write\n");
 378   LZClose(file);
 379
 380   /* Delete the file then make sure it doesn't exist anymore. */
 381   file = LZOpenFileA(filename_, &test, OF_DELETE);
 382   ok(file >= 0, "LZOpenFileA failed on delete\n");
 383   LZClose(file);
 384
 385   retval = GetFileAttributesA(filename_);
 386   ok(retval == INVALID_FILE_ATTRIBUTES,
 387      "GetFileAttributesA succeeded on deleted file\n");
 388
 389   test_LZOpenFileA_existing_compressed();
 390   test_LZOpenFileA_nonexisting_compressed();
 391 }
 392
 393 static void test_LZRead(void)
 394 {
 395   HANDLE file;
 396   DWORD ret;
 397   int cfile;
 398   OFSTRUCT test;
 399   BOOL retok;
 400
 401   /* Create the compressed file. */
 402   file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
 403   ok(file != INVALID_HANDLE_VALUE, "Could not create test file\n");
 404   retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
 405   ok( retok, "WriteFile: error %ld\n", GetLastError());
 406   ok(ret == compressed_file_size, "Wrote wrong number of bytes with WriteFile?\n");
 407   CloseHandle(file);
 408
 409   cfile = LZOpenFileA(filename_, &test, OF_READ);
 410   ok(cfile > 0, "LZOpenFileA failed\n");
 411
 412   ret = LZRead(cfile, buf, uncompressed_data_size);
 413   ok(ret == uncompressed_data_size, "Read wrong number of bytes\n");
 414
 415   /* Compare what we read with what we think we should read. */
 416   ok(memcmp(buf, uncompressed_data, uncompressed_data_size) == 0,
 417      "buffer contents mismatch\n");
 418
 419   todo_wine {
 420      /* Wine returns the number of bytes actually read instead of an error */
 421      ret = LZRead(cfile, buf, uncompressed_data_size);
 422      ok(ret == LZERROR_READ, "Expected read-past-EOF to return LZERROR_READ\n");
 423   }
 424
 425   LZClose(cfile);
 426
 427   ret = DeleteFileA(filename_);
 428   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 429 }
 430
 431 static void test_LZCopy(void)
 432 {
 433   HANDLE file;
 434   DWORD ret;
 435   int source, dest;
 436   OFSTRUCT stest, dtest;
 437   BOOL retok;
 438
 439   /* Create the compressed file. */
 440   file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
 441   ok(file != INVALID_HANDLE_VALUE,
 442      "CreateFileA: error %ld\n", GetLastError());
 443   retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
 444   ok( retok, "WriteFile error %ld\n", GetLastError());
 445   ok(ret == compressed_file_size, "Wrote wrong number of bytes\n");
 446   CloseHandle(file);
 447
 448   source = LZOpenFileA(filename_, &stest, OF_READ);
 449   ok(source >= 0, "LZOpenFileA failed on compressed file\n");
 450   dest = LZOpenFileA(filename2, &dtest, OF_CREATE);
 451   ok(dest >= 0, "LZOpenFileA failed on creating new file %d\n", dest);
 452
 453   ret = LZCopy(source, dest);
 454   ok(ret > 0, "LZCopy error\n");
 455
 456   LZClose(source);
 457   LZClose(dest);
 458
 459   file = CreateFileA(filename2, GENERIC_READ, 0, NULL, OPEN_EXISTING,
 460                     0, 0);
 461   ok(file != INVALID_HANDLE_VALUE,
 462      "CreateFileA: error %ld\n", GetLastError());
 463
 464   retok = ReadFile(file, buf, uncompressed_data_size*2, &ret, 0);
 465   ok( retok && ret == uncompressed_data_size, "ReadFile: error %ld\n", GetLastError());
 466   /* Compare what we read with what we think we should read. */
 467   ok(!memcmp(buf, uncompressed_data, uncompressed_data_size),
 468      "buffer contents mismatch\n");
 469   CloseHandle(file);
 470
 471   ret = DeleteFileA(filename_);
 472   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 473   ret = DeleteFileA(filename2);
 474   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 475 }
 476
 477 static void create_fileW(WCHAR *fnameW)
 478 {
 479   INT file;
 480   OFSTRUCT ofs;
 481   DWORD retval;
 482
 483   file = LZOpenFileW(fnameW, &ofs, OF_CREATE);
 484   ok(file >= 0, "LZOpenFileW failed on creation\n");
 485   LZClose(file);
 486   retval = GetFileAttributesW(fnameW);
 487   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesW('%s'): error %ld\n", ofs.szPathName, GetLastError());
 488 }
 489
 490 static void delete_fileW(WCHAR *fnameW)
 491 {
 492   INT file;
 493   OFSTRUCT ofs;
 494   DWORD retval;
 495
 496   file = LZOpenFileW(fnameW, &ofs, OF_DELETE);
 497   ok(file >= 0, "LZOpenFileW failed on delete\n");
 498   LZClose(file);
 499   retval = GetFileAttributesW(fnameW);
 500   ok(retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesW succeeded on deleted file ('%s')\n", ofs.szPathName);
 501 }
 502
 503 static void test_LZOpenFileW_existing_compressed(void)
 504 {
 505   OFSTRUCT test;
 506   INT file;
 507   char expected[MAX_PATH];
 508
 509   /* Try to open existing compressed files: */
 510   create_fileW(filenameW_);
 511   create_fileW(dotlessW_);
 512   create_fileW(extlessW_);
 513   create_fileW(_terminatedW_);
 514
 515   full_file_path_name_in_a_CWD(filename_, expected, FALSE);
 516   memset(&test, 0xA5, sizeof(test));
 517
 518   /* a, using 8.3-conformant file name. */
 519   file = LZOpenFileW(filenameW, &test, OF_EXIST);
 520   /* If the file "foo.xxx" does not exist, LZOpenFileW should then
 521      check for the file "foo.xx_" and open that.
 522    */
 523   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 524   ok(test.cBytes == sizeof(OFSTRUCT),
 525      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 526   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 527      test.nErrCode);
 528   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 529   ok(lstrcmpA(test.szPathName, expected) == 0,
 530      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 531      test.szPathName, expected);
 532   LZClose(file);
 533
 534   memset(&test, 0xA5, sizeof(test));
 535   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 536
 537   /* b, using dotless file name. */
 538   file = LZOpenFileW(dotlessW, &test, OF_EXIST);
 539   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 540   ok(test.cBytes == sizeof(OFSTRUCT),
 541      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 542   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 543      test.nErrCode);
 544   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 545   ok(lstrcmpA(test.szPathName, expected) == 0,
 546      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 547      test.szPathName, expected);
 548   LZClose(file);
 549
 550   memset(&test, 0xA5, sizeof(test));
 551   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 552
 553   /* c, using extensionless file name. */
 554   file = LZOpenFileW(extlessW, &test, OF_EXIST);
 555   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 556   ok(test.cBytes == sizeof(OFSTRUCT),
 557      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 558   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 559      test.nErrCode);
 560   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 561   ok(lstrcmpA(test.szPathName, expected) == 0,
 562      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 563      test.szPathName, expected);
 564   LZClose(file);
 565
 566   memset(&test, 0xA5, sizeof(test));
 567   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 568
 569   /* d, using underscore-terminated file name. */
 570   file = LZOpenFileW(_terminatedW, &test, OF_EXIST);
 571   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 572   ok(test.cBytes == sizeof(OFSTRUCT),
 573      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 574   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 575      test.nErrCode);
 576   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 577   ok(lstrcmpA(test.szPathName, expected) == 0,
 578      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 579      test.szPathName, expected);
 580   LZClose(file);
 581
 582   delete_fileW(filenameW_);
 583   delete_fileW(dotlessW_);
 584   delete_fileW(extlessW_);
 585   delete_fileW(_terminatedW_);
 586 }
 587
 588 static void test_LZOpenFileW_nonexisting_compressed(void)
 589 {
 590   OFSTRUCT test;
 591   INT file;
 592   char expected[MAX_PATH];
 593   char filled_0xA5[OFS_MAXPATHNAME];
 594
 595   /* Try to open nonexisting compressed files: */
 596   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 597   memset(&test, 0xA5, sizeof(test));
 598   full_file_path_name_in_a_CWD(filename_, expected, FALSE);
 599   SetLastError(0xfaceabee);
 600
 601   /* a, using 8.3-conformant file name. */
 602   file = LZOpenFileW(filenameW, &test, OF_EXIST);
 603   /* If the file "foo.xxx" does not exist, LZOpenFileA should then
 604      check for the file "foo.xx_" and open that -- at least on some
 605      operating systems.  Doesn't seem to on my copy of Win98.
 606    */
 607   ok(file == LZERROR_BADINHANDLE,
 608      "LZOpenFileW succeeded on nonexistent file\n");
 609   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 610      "GetLastError() returns %ld\n", GetLastError());
 611   todo_wine
 612   ok(test.cBytes == 0xA5,
 613      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 614   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 615      "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
 616   ok(lstrcmpA(test.szPathName, expected) == 0,
 617      "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
 618      test.szPathName, expected, filled_0xA5);
 619
 620   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 621   memset(&test, 0xA5, sizeof(test));
 622   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 623   SetLastError(0xfaceabee);
 624
 625   /* b, using dotless file name. */
 626   file = LZOpenFileW(dotlessW, &test, OF_EXIST);
 627   ok(file == LZERROR_BADINHANDLE,
 628      "LZOpenFileW succeeded on nonexistent file\n");
 629   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 630      "GetLastError() returns %ld\n", GetLastError());
 631   todo_wine
 632   ok(test.cBytes == 0xA5,
 633      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 634   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 635      "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
 636   ok(lstrcmpA(test.szPathName, expected) == 0,
 637      "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
 638      test.szPathName, expected, filled_0xA5);
 639
 640   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 641   memset(&test, 0xA5, sizeof(test));
 642   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 643   SetLastError(0xfaceabee);
 644
 645   /* c, using extensionless file name. */
 646   file = LZOpenFileW(extlessW, &test, OF_EXIST);
 647   ok(file == LZERROR_BADINHANDLE,
 648      "LZOpenFileW succeeded on nonexistent file\n");
 649   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 650      "GetLastError() returns %ld\n", GetLastError());
 651   todo_wine
 652   ok(test.cBytes == 0xA5,
 653      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 654   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 655      "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
 656   ok(lstrcmpA(test.szPathName, expected) == 0,
 657      "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
 658      test.szPathName, expected, filled_0xA5);
 659
 660   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 661   memset(&test, 0xA5, sizeof(test));
 662   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 663   SetLastError(0xfaceabee);
 664
 665   /* d, using underscore-terminated file name. */
 666   file = LZOpenFileW(_terminatedW, &test, OF_EXIST);
 667   ok(file == LZERROR_BADINHANDLE,
 668      "LZOpenFileW succeeded on nonexistent file\n");
 669   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 670      "GetLastError() returns %ld\n", GetLastError());
 671   todo_wine
 672   ok(test.cBytes == 0xA5,
 673      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 674   ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 675      "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
 676   ok(lstrcmpA(test.szPathName, expected) == 0,
 677      "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
 678      test.szPathName, expected, filled_0xA5);
 679 }
 680
 681 static void test_LZOpenFileW(void)
 682 {
 683   OFSTRUCT test;
 684   DWORD retval;
 685   INT file;
 686   static WCHAR badfilenameW[] = {'b','a','d','f','i','l','e','n','a','m','e','.','x','t','n',0};
 687
 688   SetLastError(0xfaceabee);
 689   /* Check for nonexistent file. */
 690   file = LZOpenFileW(badfilenameW, &test, OF_READ);
 691   ok(GetLastError() == ERROR_FILE_NOT_FOUND || GetLastError() == ERROR_CALL_NOT_IMPLEMENTED,
 692      "GetLastError() returns %ld\n", GetLastError());
 693   if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 694   {
 695     trace("LZOpenFileW call not implemented, skipping rest of the test\n");
 696     return;
 697   }
 698   ok(file == LZERROR_BADINHANDLE,
 699      "LZOpenFileW succeeded on nonexistent file\n");
 700   LZClose(file);
 701
 702   /* Create an empty file. */
 703   file = LZOpenFileW(filenameW_, &test, OF_CREATE);
 704   ok(file >= 0, "LZOpenFile failed on creation\n");
 705   LZClose(file);
 706   retval = GetFileAttributesW(filenameW_);
 707   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributes: error %ld\n",
 708     GetLastError());
 709
 710   /* Check various opening options. */
 711   file = LZOpenFileW(filenameW_, &test, OF_READ);
 712   ok(file >= 0, "LZOpenFileW failed on read\n");
 713   LZClose(file);
 714   file = LZOpenFileW(filenameW_, &test, OF_WRITE);
 715   ok(file >= 0, "LZOpenFileW failed on write\n");
 716   LZClose(file);
 717   file = LZOpenFileW(filenameW_, &test, OF_READWRITE);
 718   ok(file >= 0, "LZOpenFileW failed on read/write\n");
 719   LZClose(file);
 720   file = LZOpenFileW(filenameW_, &test, OF_EXIST);
 721   ok(file >= 0, "LZOpenFileW failed on read/write\n");
 722   LZClose(file);
 723
 724   /* Delete the file then make sure it doesn't exist anymore. */
 725   file = LZOpenFileW(filenameW_, &test, OF_DELETE);
 726   ok(file >= 0, "LZOpenFileW failed on delete\n");
 727   LZClose(file);
 728
 729   retval = GetFileAttributesW(filenameW_);
 730   ok(retval == INVALID_FILE_ATTRIBUTES,
 731      "GetFileAttributesW succeeded on deleted file\n");
 732
 733   test_LZOpenFileW_existing_compressed();
 734   test_LZOpenFileW_nonexisting_compressed();
 735 }
 736
 737
 738 START_TEST(lzexpand_main)
 739 {
 740   buf = malloc(uncompressed_data_size * 2);
 741   test_LZOpenFileA();
 742   test_LZOpenFileW();
 743   test_LZRead();
 744   test_LZCopy();
 745   free(buf);
 746 }