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
 135   /* a, using 8.3-conformant file name. */
 136   file = LZOpenFileA(filename, &test, OF_EXIST);
 137   /* If the file "foo.xxx" does not exist, LZOpenFileA should then
 138      check for the file "foo.xx_" and open that -- at least on some
 139      operating systems.  Doesn't seem to on my copy of Win98.
 140    */
 141   if(file != LZERROR_BADINHANDLE) {
 142     ok(test.cBytes == sizeof(OFSTRUCT),
 143        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 144     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 145        test.nErrCode);
 146     ok(lstrcmpA(test.szPathName, expected) == 0,
 147        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 148        test.szPathName, expected);
 149     LZClose(file);
 150   } else { /* Win9x */
 151     ok(test.cBytes == 0xA5,
 152        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 153     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 154        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 155     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 156        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 157        test.szPathName, filled_0xA5);
 158   }
 159
 160   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 161   memset(&test, 0xA5, sizeof(test));
 162   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 163
 164   /* b, using dotless file name. */
 165   file = LZOpenFileA(dotless, &test, OF_EXIST);
 166   if(file != LZERROR_BADINHANDLE) {
 167     ok(test.cBytes == sizeof(OFSTRUCT),
 168        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 169     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 170        test.nErrCode);
 171     ok(lstrcmpA(test.szPathName, expected) == 0,
 172        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 173        test.szPathName, expected);
 174     LZClose(file);
 175   } else { /* Win9x */
 176     todo_wine
 177     ok(test.cBytes == 0xA5,
 178        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 179     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 180        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 181     todo_wine
 182     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 183        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 184        test.szPathName, filled_0xA5);
 185   }
 186
 187   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 188   memset(&test, 0xA5, sizeof(test));
 189   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 190
 191   /* c, using extensionless file name. */
 192   file = LZOpenFileA(extless, &test, OF_EXIST);
 193   if(file != LZERROR_BADINHANDLE) {
 194     ok(test.cBytes == sizeof(OFSTRUCT),
 195        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 196     ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 197        test.nErrCode);
 198     ok(lstrcmpA(test.szPathName, expected) == 0,
 199        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 200        test.szPathName, expected);
 201     LZClose(file);
 202   } else { /* Win9x */
 203     ok(test.cBytes == 0xA5,
 204        "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 205     ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
 206        "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
 207     ok(strncmp(test.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
 208        "LZOpenFileA returned '%s', but was expected to return '%s'\n",
 209        test.szPathName, filled_0xA5);
 210   }
 211
 212   memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
 213   memset(&test, 0xA5, sizeof(test));
 214   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 215   full_file_path_name_in_a_CWD(_terminated_, short_expected, TRUE);
 216
 217   /* d, using underscore-terminated file name. */
 218   file = LZOpenFileA(_terminated, &test, OF_EXIST);
 219   ok(file >= 0, "LZOpenFileA failed on switching to a compressed file name\n");
 220   ok(test.cBytes == sizeof(OFSTRUCT),
 221      "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
 222   ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
 223      test.nErrCode);
 224   ok(lstrcmpA(test.szPathName, expected) == 0 ||
 225      lstrcmpA(test.szPathName, short_expected) == 0, /* Win9x */
 226      "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
 227      test.szPathName, expected, short_expected);
 228   LZClose(file);
 229
 230   delete_file(filename_);
 231   delete_file(dotless_);
 232   delete_file(extless_);
 233   delete_file(_terminated_);
 234 }
 235
 236 static void test_LZOpenFileA(void)
 237 {
 238   OFSTRUCT test;
 239   DWORD retval;
 240   INT file;
 241   static char badfilename_[] = "badfilename_";
 242
 243   SetLastError(0xfaceabee);
 244   /* Check for nonexistent file. */
 245   file = LZOpenFileA(badfilename_, &test, OF_READ);
 246   ok(file == LZERROR_BADINHANDLE,
 247      "LZOpenFileA succeeded on nonexistent file\n");
 248   ok(GetLastError() == ERROR_FILE_NOT_FOUND,
 249      "GetLastError() returns %ld\n", GetLastError());
 250   LZClose(file);
 251
 252   /* Create an empty file. */
 253   file = LZOpenFileA(filename_, &test, OF_CREATE);
 254   ok(file >= 0, "LZOpenFileA failed on creation\n");
 255   LZClose(file);
 256   retval = GetFileAttributesA(filename_);
 257   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %ld\n",
 258      GetLastError());
 259
 260   /* Check various opening options. */
 261   file = LZOpenFileA(filename_, &test, OF_READ);
 262   ok(file >= 0, "LZOpenFileA failed on read\n");
 263   LZClose(file);
 264   file = LZOpenFileA(filename_, &test, OF_WRITE);
 265   ok(file >= 0, "LZOpenFileA failed on write\n");
 266   LZClose(file);
 267   file = LZOpenFileA(filename_, &test, OF_READWRITE);
 268   ok(file >= 0, "LZOpenFileA failed on read/write\n");
 269   LZClose(file);
 270   file = LZOpenFileA(filename_, &test, OF_EXIST);
 271   ok(file >= 0, "LZOpenFileA failed on read/write\n");
 272   LZClose(file);
 273
 274   /* Delete the file then make sure it doesn't exist anymore. */
 275   file = LZOpenFileA(filename_, &test, OF_DELETE);
 276   ok(file >= 0, "LZOpenFileA failed on delete\n");
 277   LZClose(file);
 278
 279   retval = GetFileAttributesA(filename_);
 280   ok(retval == INVALID_FILE_ATTRIBUTES,
 281      "GetFileAttributesA succeeded on deleted file\n");
 282
 283   test_LZOpenFileA_existing_compressed();
 284 }
 285
 286 static void test_LZRead(void)
 287 {
 288   HANDLE file;
 289   DWORD ret;
 290   int cfile;
 291   OFSTRUCT test;
 292   BOOL retok;
 293
 294   /* Create the compressed file. */
 295   file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
 296   ok(file != INVALID_HANDLE_VALUE, "Could not create test file\n");
 297   retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
 298   ok( retok, "WriteFile: error %ld\n", GetLastError());
 299   ok(ret == compressed_file_size, "Wrote wrong number of bytes with WriteFile?\n");
 300   CloseHandle(file);
 301
 302   cfile = LZOpenFileA(filename_, &test, OF_READ);
 303   ok(cfile > 0, "LZOpenFileA failed\n");
 304
 305   ret = LZRead(cfile, buf, uncompressed_data_size);
 306   ok(ret == uncompressed_data_size, "Read wrong number of bytes\n");
 307
 308   /* Compare what we read with what we think we should read. */
 309   ok(memcmp(buf, uncompressed_data, uncompressed_data_size) == 0,
 310      "buffer contents mismatch\n");
 311
 312   todo_wine {
 313      /* Wine returns the number of bytes actually read instead of an error */
 314      ret = LZRead(cfile, buf, uncompressed_data_size);
 315      ok(ret == LZERROR_READ, "Expected read-past-EOF to return LZERROR_READ\n");
 316   }
 317
 318   LZClose(cfile);
 319
 320   ret = DeleteFileA(filename_);
 321   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 322 }
 323
 324 static void test_LZCopy(void)
 325 {
 326   HANDLE file;
 327   DWORD ret;
 328   int source, dest;
 329   OFSTRUCT stest, dtest;
 330   BOOL retok;
 331
 332   /* Create the compressed file. */
 333   file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
 334   ok(file != INVALID_HANDLE_VALUE,
 335      "CreateFileA: error %ld\n", GetLastError());
 336   retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
 337   ok( retok, "WriteFile error %ld\n", GetLastError());
 338   ok(ret == compressed_file_size, "Wrote wrong number of bytes\n");
 339   CloseHandle(file);
 340
 341   source = LZOpenFileA(filename_, &stest, OF_READ);
 342   ok(source >= 0, "LZOpenFileA failed on compressed file\n");
 343   dest = LZOpenFileA(filename2, &dtest, OF_CREATE);
 344   ok(dest >= 0, "LZOpenFileA failed on creating new file %d\n", dest);
 345
 346   ret = LZCopy(source, dest);
 347   ok(ret > 0, "LZCopy error\n");
 348
 349   LZClose(source);
 350   LZClose(dest);
 351
 352   file = CreateFileA(filename2, GENERIC_READ, 0, NULL, OPEN_EXISTING,
 353                     0, 0);
 354   ok(file != INVALID_HANDLE_VALUE,
 355      "CreateFileA: error %ld\n", GetLastError());
 356
 357   retok = ReadFile(file, buf, uncompressed_data_size*2, &ret, 0);
 358   ok( retok && ret == uncompressed_data_size, "ReadFile: error %ld\n", GetLastError());
 359   /* Compare what we read with what we think we should read. */
 360   ok(!memcmp(buf, uncompressed_data, uncompressed_data_size),
 361      "buffer contents mismatch\n");
 362   CloseHandle(file);
 363
 364   ret = DeleteFileA(filename_);
 365   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 366   ret = DeleteFileA(filename2);
 367   ok(ret, "DeleteFileA: error %ld\n", GetLastError());
 368 }
 369
 370 static void create_fileW(WCHAR *fnameW)
 371 {
 372   INT file;
 373   OFSTRUCT ofs;
 374   DWORD retval;
 375
 376   file = LZOpenFileW(fnameW, &ofs, OF_CREATE);
 377   ok(file >= 0, "LZOpenFileA failed on creation\n");
 378   LZClose(file);
 379   retval = GetFileAttributesW(fnameW);
 380   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA('%s'): error %ld\n", ofs.szPathName, GetLastError());
 381 }
 382
 383 static void delete_fileW(WCHAR *fnameW)
 384 {
 385   INT file;
 386   OFSTRUCT ofs;
 387   DWORD retval;
 388
 389   file = LZOpenFileW(fnameW, &ofs, OF_DELETE);
 390   ok(file >= 0, "LZOpenFileA failed on delete\n");
 391   LZClose(file);
 392   retval = GetFileAttributesW(fnameW);
 393   ok(retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file ('%s')\n", ofs.szPathName);
 394 }
 395
 396 static void test_LZOpenFileW_existing_compressed(void)
 397 {
 398   OFSTRUCT test;
 399   INT file;
 400   char expected[MAX_PATH];
 401
 402   /* Try to open existing compressed files: */
 403   create_fileW(filenameW_);
 404   create_fileW(dotlessW_);
 405   create_fileW(extlessW_);
 406   create_fileW(_terminatedW_);
 407
 408   full_file_path_name_in_a_CWD(filename_, expected, FALSE);
 409   memset(&test, 0xA5, sizeof(test));
 410
 411   /* a, using 8.3-conformant file name. */
 412   file = LZOpenFileW(filenameW, &test, OF_EXIST);
 413   /* If the file "foo.xxx" does not exist, LZOpenFileW should then
 414      check for the file "foo.xx_" and open that.
 415    */
 416   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 417   ok(test.cBytes == sizeof(OFSTRUCT),
 418      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 419   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 420      test.nErrCode);
 421   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 422   ok(lstrcmpA(test.szPathName, expected) == 0,
 423      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 424      test.szPathName, expected);
 425   LZClose(file);
 426
 427   memset(&test, 0xA5, sizeof(test));
 428   full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
 429
 430   /* b, using dotless file name. */
 431   file = LZOpenFileW(dotlessW, &test, OF_EXIST);
 432   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 433   ok(test.cBytes == sizeof(OFSTRUCT),
 434      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 435   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 436      test.nErrCode);
 437   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 438   ok(lstrcmpA(test.szPathName, expected) == 0,
 439      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 440      test.szPathName, expected);
 441   LZClose(file);
 442
 443   memset(&test, 0xA5, sizeof(test));
 444   full_file_path_name_in_a_CWD(extless_, expected, FALSE);
 445
 446   /* c, using extensionless file name. */
 447   file = LZOpenFileW(extlessW, &test, OF_EXIST);
 448   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 449   ok(test.cBytes == sizeof(OFSTRUCT),
 450      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 451   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 452      test.nErrCode);
 453   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 454   ok(lstrcmpA(test.szPathName, expected) == 0,
 455      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 456      test.szPathName, expected);
 457   LZClose(file);
 458
 459   memset(&test, 0xA5, sizeof(test));
 460   full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
 461
 462   /* d, using underscore-terminated file name. */
 463   file = LZOpenFileW(_terminatedW, &test, OF_EXIST);
 464   ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
 465   ok(test.cBytes == sizeof(OFSTRUCT),
 466      "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
 467   ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
 468      test.nErrCode);
 469   /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
 470   ok(lstrcmpA(test.szPathName, expected) == 0,
 471      "LZOpenFileW returned '%s', but was expected to return '%s'\n",
 472      test.szPathName, expected);
 473   LZClose(file);
 474
 475   delete_fileW(filenameW_);
 476   delete_fileW(dotlessW_);
 477   delete_fileW(extlessW_);
 478   delete_fileW(_terminatedW_);
 479 }
 480
 481 static void test_LZOpenFileW(void)
 482 {
 483   OFSTRUCT test;
 484   DWORD retval;
 485   INT file;
 486   static WCHAR badfilenameW[] = {'b','a','d','f','i','l','e','n','a','m','e','.','x','t','n',0};
 487
 488   SetLastError(0xfaceabee);
 489   /* Check for nonexistent file. */
 490   file = LZOpenFileW(badfilenameW, &test, OF_READ);
 491   if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 492   {
 493     trace("LZOpenFileW call not implemented, skipping rest of the test\n");
 494     return;
 495   }
 496   ok(file == LZERROR_BADINHANDLE,
 497      "LZOpenFileW succeeded on nonexistent file\n");
 498   LZClose(file);
 499
 500   /* Create an empty file. */
 501   file = LZOpenFileW(filenameW_, &test, OF_CREATE);
 502   ok(file >= 0, "LZOpenFile failed on creation\n");
 503   LZClose(file);
 504   retval = GetFileAttributesW(filenameW_);
 505   ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributes: error %ld\n",
 506     GetLastError());
 507
 508   /* Check various opening options. */
 509   file = LZOpenFileW(filenameW_, &test, OF_READ);
 510   ok(file >= 0, "LZOpenFileW failed on read\n");
 511   LZClose(file);
 512   file = LZOpenFileW(filenameW_, &test, OF_WRITE);
 513   ok(file >= 0, "LZOpenFileW failed on write\n");
 514   LZClose(file);
 515   file = LZOpenFileW(filenameW_, &test, OF_READWRITE);
 516   ok(file >= 0, "LZOpenFileW failed on read/write\n");
 517   LZClose(file);
 518   file = LZOpenFileW(filenameW_, &test, OF_EXIST);
 519   ok(file >= 0, "LZOpenFileW failed on read/write\n");
 520   LZClose(file);
 521
 522   /* Delete the file then make sure it doesn't exist anymore. */
 523   file = LZOpenFileW(filenameW_, &test, OF_DELETE);
 524   ok(file >= 0, "LZOpenFileW failed on delete\n");
 525   LZClose(file);
 526
 527   retval = GetFileAttributesW(filenameW_);
 528   ok(retval == INVALID_FILE_ATTRIBUTES,
 529      "GetFileAttributesW succeeded on deleted file\n");
 530
 531   test_LZOpenFileW_existing_compressed();
 532 }
 533
 534
 535 START_TEST(lzexpand_main)
 536 {
 537   buf = malloc(uncompressed_data_size * 2);
 538   test_LZOpenFileA();
 539   test_LZOpenFileW();
 540   test_LZRead();
 541   test_LZCopy();
 542   free(buf);
 543 }