2 * Unit test suite for lz32 functions
4 * Copyright 2004 Evan Parry, Daniel Kegel
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.
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.
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
28 #include "wine/test.h"
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};
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};
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};
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};
51 static char filename2
[] = "testfile.yyy";
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."
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
60 http://www.microsoft.com/downloads/details.aspx?FamilyID=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en
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
);
69 static const char uncompressed_data
[] = "This is a test file.";
70 static const DWORD uncompressed_data_size
= sizeof(uncompressed_data
) - 1;
74 static void full_file_path_name_in_a_CWD(const char *src
, char *dst
, BOOL expect_short
)
77 char shortname
[MAX_PATH
];
79 retval
= GetCurrentDirectoryA(MAX_PATH
, dst
);
80 ok(retval
> 0, "GetCurrentDirectoryA returned %ld, GLE=%ld\n",
81 retval
, GetLastError());
82 if(dst
[retval
-1] != '\\')
83 /* Append backslash only when it's missing */
88 memcpy(shortname
, dst
, MAX_PATH
);
89 retval
= GetShortPathName(shortname
, dst
, MAX_PATH
-1);
90 ok(retval
> 0, "GetShortPathName returned %ld for '%s', GLE=%ld\n",
91 retval
, dst
, GetLastError());
95 static void create_file(char *fname
)
101 file
= LZOpenFileA(fname
, &ofs
, OF_CREATE
);
102 ok(file
>= 0, "LZOpenFileA failed to create '%s'\n", fname
);
104 retval
= GetFileAttributesA(fname
);
105 ok(retval
!= INVALID_FILE_ATTRIBUTES
, "GetFileAttributesA('%s'): error %ld\n", ofs
.szPathName
, GetLastError());
108 static void delete_file(char *fname
)
114 file
= LZOpenFileA(fname
, &ofs
, OF_DELETE
);
115 ok(file
>= 0, "LZOpenFileA failed to delete '%s'\n", fname
);
117 retval
= GetFileAttributesA(fname
);
118 ok(retval
== INVALID_FILE_ATTRIBUTES
, "GetFileAttributesA succeeded on deleted file ('%s')\n", ofs
.szPathName
);
121 static void test_LZOpenFileA_existing_compressed(void)
125 char expected
[MAX_PATH
];
126 char short_expected
[MAX_PATH
];
127 char filled_0xA5
[OFS_MAXPATHNAME
];
129 /* Try to open existing compressed files: */
130 create_file(filename_
);
131 create_file(dotless_
);
132 create_file(extless_
);
133 create_file(_terminated_
);
135 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
136 memset(&test
, 0xA5, sizeof(test
));
137 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
138 SetLastError(0xfaceabee);
140 /* a, using 8.3-conformant file name. */
141 file
= LZOpenFileA(filename
, &test
, OF_EXIST
);
142 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
143 check for the file "foo.xx_" and open that -- at least on some
144 operating systems. Doesn't seem to on my copy of Win98.
146 if(file
!= LZERROR_BADINHANDLE
) {
147 ok(file
>= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", filename
);
148 ok(test
.cBytes
== sizeof(OFSTRUCT
),
149 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
150 ok(test
.nErrCode
== 0, "LZOpenFileA set test.nErrCode to %d\n",
152 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
153 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
154 test
.szPathName
, expected
);
157 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
158 "GetLastError() returns %ld\n", GetLastError());
159 ok(test
.cBytes
== 0xA5,
160 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
161 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
162 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
163 ok(strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0,
164 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
165 test
.szPathName
, filled_0xA5
);
168 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
169 memset(&test
, 0xA5, sizeof(test
));
170 full_file_path_name_in_a_CWD(dotless_
, expected
, FALSE
);
171 SetLastError(0xfaceabee);
173 /* b, using dotless file name. */
174 file
= LZOpenFileA(dotless
, &test
, OF_EXIST
);
175 if(file
!= LZERROR_BADINHANDLE
) {
176 ok(file
>= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", dotless
);
177 ok(test
.cBytes
== sizeof(OFSTRUCT
),
178 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
179 ok(test
.nErrCode
== 0, "LZOpenFileA set test.nErrCode to %d\n",
181 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
182 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
183 test
.szPathName
, expected
);
186 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
187 "GetLastError() returns %ld\n", GetLastError());
189 ok(test
.cBytes
== 0xA5,
190 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
191 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
192 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
194 ok(strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0,
195 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
196 test
.szPathName
, filled_0xA5
);
199 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
200 memset(&test
, 0xA5, sizeof(test
));
201 full_file_path_name_in_a_CWD(extless_
, expected
, FALSE
);
202 SetLastError(0xfaceabee);
204 /* c, using extensionless file name. */
205 file
= LZOpenFileA(extless
, &test
, OF_EXIST
);
206 if(file
!= LZERROR_BADINHANDLE
) {
207 ok(file
>= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", extless
);
208 ok(test
.cBytes
== sizeof(OFSTRUCT
),
209 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
210 ok(test
.nErrCode
== 0, "LZOpenFileA set test.nErrCode to %d\n",
212 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
213 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
214 test
.szPathName
, expected
);
217 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
218 "GetLastError() returns %ld\n", GetLastError());
219 ok(test
.cBytes
== 0xA5,
220 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
221 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
222 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
223 ok(strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0,
224 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
225 test
.szPathName
, filled_0xA5
);
228 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
229 memset(&test
, 0xA5, sizeof(test
));
230 full_file_path_name_in_a_CWD(_terminated_
, expected
, FALSE
);
231 full_file_path_name_in_a_CWD(_terminated_
, short_expected
, TRUE
);
233 /* d, using underscore-terminated file name. */
234 file
= LZOpenFileA(_terminated
, &test
, OF_EXIST
);
235 ok(file
>= 0, "LZOpenFileA failed on switching to a compressed file name\n");
236 ok(test
.cBytes
== sizeof(OFSTRUCT
),
237 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
238 ok(test
.nErrCode
== 0, "LZOpenFileA set test.nErrCode to %d\n",
240 ok(lstrcmpA(test
.szPathName
, expected
) == 0 ||
241 lstrcmpA(test
.szPathName
, short_expected
) == 0, /* Win9x */
242 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
243 test
.szPathName
, expected
, short_expected
);
246 delete_file(filename_
);
247 delete_file(dotless_
);
248 delete_file(extless_
);
249 delete_file(_terminated_
);
252 static void test_LZOpenFileA_nonexisting_compressed(void)
256 char expected
[MAX_PATH
];
257 char filled_0xA5
[OFS_MAXPATHNAME
];
259 /* Try to open nonexisting compressed files: */
260 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
261 memset(&test
, 0xA5, sizeof(test
));
262 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
263 SetLastError(0xfaceabee);
265 /* a, using 8.3-conformant file name. */
266 file
= LZOpenFileA(filename
, &test
, OF_EXIST
);
267 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
268 check for the file "foo.xx_" and open that -- at least on some
269 operating systems. Doesn't seem to on my copy of Win98.
271 ok(file
== LZERROR_BADINHANDLE
,
272 "LZOpenFileA succeeded on nonexistent file\n");
273 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
274 "GetLastError() returns %ld\n", GetLastError());
276 ok(test
.cBytes
== 0xA5,
277 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
278 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
279 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
280 ok(lstrcmpA(test
.szPathName
, expected
) == 0 ||
281 strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0, /* Win9x */
282 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
283 test
.szPathName
, expected
, filled_0xA5
);
285 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
286 memset(&test
, 0xA5, sizeof(test
));
287 full_file_path_name_in_a_CWD(dotless_
, expected
, FALSE
);
288 SetLastError(0xfaceabee);
290 /* b, using dotless file name. */
291 file
= LZOpenFileA(dotless
, &test
, OF_EXIST
);
292 ok(file
== LZERROR_BADINHANDLE
,
293 "LZOpenFileA succeeded on nonexistent file\n");
294 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
295 "GetLastError() returns %ld\n", GetLastError());
297 ok(test
.cBytes
== 0xA5,
298 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
299 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
300 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
301 ok(lstrcmpA(test
.szPathName
, expected
) == 0 ||
302 strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0, /* Win9x */
303 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
304 test
.szPathName
, expected
, filled_0xA5
);
306 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
307 memset(&test
, 0xA5, sizeof(test
));
308 full_file_path_name_in_a_CWD(extless_
, expected
, FALSE
);
309 SetLastError(0xfaceabee);
311 /* c, using extensionless file name. */
312 file
= LZOpenFileA(extless
, &test
, OF_EXIST
);
313 ok(file
== LZERROR_BADINHANDLE
,
314 "LZOpenFileA succeeded on nonexistent file\n");
315 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
316 "GetLastError() returns %ld\n", GetLastError());
318 ok(test
.cBytes
== 0xA5,
319 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
320 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
321 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
322 ok(lstrcmpA(test
.szPathName
, expected
) == 0 ||
323 strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0, /* Win9x */
324 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
325 test
.szPathName
, expected
, filled_0xA5
);
327 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
328 memset(&test
, 0xA5, sizeof(test
));
329 full_file_path_name_in_a_CWD(_terminated_
, expected
, FALSE
);
330 SetLastError(0xfaceabee);
332 /* d, using underscore-terminated file name. */
333 file
= LZOpenFileA(_terminated
, &test
, OF_EXIST
);
334 ok(file
== LZERROR_BADINHANDLE
,
335 "LZOpenFileA succeeded on nonexistent file\n");
336 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
337 "GetLastError() returns %ld\n", GetLastError());
339 ok(test
.cBytes
== 0xA5,
340 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
341 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
342 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
343 ok(lstrcmpA(test
.szPathName
, expected
) == 0 ||
344 strncmp(test
.szPathName
, filled_0xA5
, OFS_MAXPATHNAME
) == 0, /* Win9x */
345 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
346 test
.szPathName
, expected
, filled_0xA5
);
349 static void test_LZOpenFileA(void)
354 static char badfilename_
[] = "badfilename_";
355 char expected
[MAX_PATH
];
357 SetLastError(0xfaceabee);
358 /* Check for nonexistent file. */
359 file
= LZOpenFileA(badfilename_
, &test
, OF_READ
);
360 ok(file
== LZERROR_BADINHANDLE
,
361 "LZOpenFileA succeeded on nonexistent file\n");
362 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
363 "GetLastError() returns %ld\n", GetLastError());
366 memset(&test
, 0xA5, sizeof(test
));
367 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
369 /* Create an empty file. */
370 file
= LZOpenFileA(filename_
, &test
, OF_CREATE
);
371 ok(file
>= 0, "LZOpenFileA failed on creation\n");
372 ok(test
.cBytes
== sizeof(OFSTRUCT
),
373 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
374 ok(test
.nErrCode
== ERROR_SUCCESS
,
375 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
376 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
377 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
378 test
.szPathName
, expected
);
381 retval
= GetFileAttributesA(filename_
);
382 ok(retval
!= INVALID_FILE_ATTRIBUTES
, "GetFileAttributesA: error %ld\n",
385 /* Check various opening options: */
386 memset(&test
, 0xA5, sizeof(test
));
388 /* a, for reading. */
389 file
= LZOpenFileA(filename_
, &test
, OF_READ
);
390 ok(file
>= 0, "LZOpenFileA failed on read\n");
391 ok(test
.cBytes
== sizeof(OFSTRUCT
),
392 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
393 ok(test
.nErrCode
== ERROR_SUCCESS
,
394 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
395 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
396 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
397 test
.szPathName
, expected
);
400 memset(&test
, 0xA5, sizeof(test
));
402 /* b, for writing. */
403 file
= LZOpenFileA(filename_
, &test
, OF_WRITE
);
404 ok(file
>= 0, "LZOpenFileA failed on write\n");
405 ok(test
.cBytes
== sizeof(OFSTRUCT
),
406 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
407 ok(test
.nErrCode
== ERROR_SUCCESS
,
408 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
409 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
410 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
411 test
.szPathName
, expected
);
414 memset(&test
, 0xA5, sizeof(test
));
416 /* c, for reading and writing. */
417 file
= LZOpenFileA(filename_
, &test
, OF_READWRITE
);
418 ok(file
>= 0, "LZOpenFileA failed on read/write\n");
419 ok(test
.cBytes
== sizeof(OFSTRUCT
),
420 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
421 ok(test
.nErrCode
== ERROR_SUCCESS
,
422 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
423 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
424 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
425 test
.szPathName
, expected
);
428 memset(&test
, 0xA5, sizeof(test
));
430 /* d, for checking file existance. */
431 file
= LZOpenFileA(filename_
, &test
, OF_EXIST
);
432 ok(file
>= 0, "LZOpenFileA failed on read/write\n");
433 ok(test
.cBytes
== sizeof(OFSTRUCT
),
434 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
435 ok(test
.nErrCode
== ERROR_SUCCESS
,
436 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
437 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
438 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
439 test
.szPathName
, expected
);
442 memset(&test
, 0xA5, sizeof(test
));
444 /* Delete the file then make sure it doesn't exist anymore. */
445 file
= LZOpenFileA(filename_
, &test
, OF_DELETE
);
446 ok(file
>= 0, "LZOpenFileA failed on delete\n");
447 ok(test
.cBytes
== sizeof(OFSTRUCT
),
448 "LZOpenFileA set test.cBytes to %d\n", test
.cBytes
);
449 ok(test
.nErrCode
== ERROR_SUCCESS
,
450 "LZOpenFileA set test.nErrCode to %d\n", test
.nErrCode
);
451 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
452 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
453 test
.szPathName
, expected
);
456 retval
= GetFileAttributesA(filename_
);
457 ok(retval
== INVALID_FILE_ATTRIBUTES
,
458 "GetFileAttributesA succeeded on deleted file\n");
460 test_LZOpenFileA_existing_compressed();
461 test_LZOpenFileA_nonexisting_compressed();
464 static void test_LZRead(void)
472 /* Create the compressed file. */
473 file
= CreateFileA(filename_
, GENERIC_WRITE
, 0, NULL
, CREATE_NEW
, 0, 0);
474 ok(file
!= INVALID_HANDLE_VALUE
, "Could not create test file\n");
475 retok
= WriteFile(file
, compressed_file
, compressed_file_size
, &ret
, 0);
476 ok( retok
, "WriteFile: error %ld\n", GetLastError());
477 ok(ret
== compressed_file_size
, "Wrote wrong number of bytes with WriteFile?\n");
480 cfile
= LZOpenFileA(filename_
, &test
, OF_READ
);
481 ok(cfile
> 0, "LZOpenFileA failed\n");
483 ret
= LZRead(cfile
, buf
, uncompressed_data_size
);
484 ok(ret
== uncompressed_data_size
, "Read wrong number of bytes\n");
486 /* Compare what we read with what we think we should read. */
487 ok(memcmp(buf
, uncompressed_data
, uncompressed_data_size
) == 0,
488 "buffer contents mismatch\n");
491 /* Wine returns the number of bytes actually read instead of an error */
492 ret
= LZRead(cfile
, buf
, uncompressed_data_size
);
493 ok(ret
== LZERROR_READ
, "Expected read-past-EOF to return LZERROR_READ\n");
498 ret
= DeleteFileA(filename_
);
499 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
502 static void test_LZCopy(void)
507 OFSTRUCT stest
, dtest
;
510 /* Create the compressed file. */
511 file
= CreateFileA(filename_
, GENERIC_WRITE
, 0, NULL
, CREATE_NEW
, 0, 0);
512 ok(file
!= INVALID_HANDLE_VALUE
,
513 "CreateFileA: error %ld\n", GetLastError());
514 retok
= WriteFile(file
, compressed_file
, compressed_file_size
, &ret
, 0);
515 ok( retok
, "WriteFile error %ld\n", GetLastError());
516 ok(ret
== compressed_file_size
, "Wrote wrong number of bytes\n");
519 source
= LZOpenFileA(filename_
, &stest
, OF_READ
);
520 ok(source
>= 0, "LZOpenFileA failed on compressed file\n");
521 dest
= LZOpenFileA(filename2
, &dtest
, OF_CREATE
);
522 ok(dest
>= 0, "LZOpenFileA failed on creating new file %d\n", dest
);
524 ret
= LZCopy(source
, dest
);
525 ok(ret
> 0, "LZCopy error\n");
530 file
= CreateFileA(filename2
, GENERIC_READ
, 0, NULL
, OPEN_EXISTING
, 0, 0);
531 ok(file
!= INVALID_HANDLE_VALUE
,
532 "CreateFileA: error %ld\n", GetLastError());
534 retok
= ReadFile(file
, buf
, uncompressed_data_size
*2, &ret
, 0);
535 ok( retok
&& ret
== uncompressed_data_size
, "ReadFile: error %ld\n", GetLastError());
536 /* Compare what we read with what we think we should read. */
537 ok(!memcmp(buf
, uncompressed_data
, uncompressed_data_size
),
538 "buffer contents mismatch\n");
541 ret
= DeleteFileA(filename_
);
542 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
543 ret
= DeleteFileA(filename2
);
544 ok(ret
, "DeleteFileA: error %ld\n", GetLastError());
547 static void create_fileW(WCHAR
*fnameW
)
553 file
= LZOpenFileW(fnameW
, &ofs
, OF_CREATE
);
554 ok(file
>= 0, "LZOpenFileW failed on creation\n");
556 retval
= GetFileAttributesW(fnameW
);
557 ok(retval
!= INVALID_FILE_ATTRIBUTES
, "GetFileAttributesW('%s'): error %ld\n", ofs
.szPathName
, GetLastError());
560 static void delete_fileW(WCHAR
*fnameW
)
566 file
= LZOpenFileW(fnameW
, &ofs
, OF_DELETE
);
567 ok(file
>= 0, "LZOpenFileW failed on delete\n");
569 retval
= GetFileAttributesW(fnameW
);
570 ok(retval
== INVALID_FILE_ATTRIBUTES
, "GetFileAttributesW succeeded on deleted file ('%s')\n", ofs
.szPathName
);
573 static void test_LZOpenFileW_existing_compressed(void)
577 char expected
[MAX_PATH
];
579 /* Try to open existing compressed files: */
580 create_fileW(filenameW_
);
581 create_fileW(dotlessW_
);
582 create_fileW(extlessW_
);
583 create_fileW(_terminatedW_
);
585 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
586 memset(&test
, 0xA5, sizeof(test
));
588 /* a, using 8.3-conformant file name. */
589 file
= LZOpenFileW(filenameW
, &test
, OF_EXIST
);
590 /* If the file "foo.xxx" does not exist, LZOpenFileW should then
591 check for the file "foo.xx_" and open that.
593 ok(file
>= 0, "LZOpenFileW failed on switching to a compressed file name\n");
594 ok(test
.cBytes
== sizeof(OFSTRUCT
),
595 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
596 ok(test
.nErrCode
== ERROR_SUCCESS
, "LZOpenFileW set test.nErrCode to %d\n",
598 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
599 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
600 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
601 test
.szPathName
, expected
);
604 memset(&test
, 0xA5, sizeof(test
));
605 full_file_path_name_in_a_CWD(dotless_
, expected
, FALSE
);
607 /* b, using dotless file name. */
608 file
= LZOpenFileW(dotlessW
, &test
, OF_EXIST
);
609 ok(file
>= 0, "LZOpenFileW failed on switching to a compressed file name\n");
610 ok(test
.cBytes
== sizeof(OFSTRUCT
),
611 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
612 ok(test
.nErrCode
== ERROR_SUCCESS
, "LZOpenFileW set test.nErrCode to %d\n",
614 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
615 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
616 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
617 test
.szPathName
, expected
);
620 memset(&test
, 0xA5, sizeof(test
));
621 full_file_path_name_in_a_CWD(extless_
, expected
, FALSE
);
623 /* c, using extensionless file name. */
624 file
= LZOpenFileW(extlessW
, &test
, OF_EXIST
);
625 ok(file
>= 0, "LZOpenFileW failed on switching to a compressed file name\n");
626 ok(test
.cBytes
== sizeof(OFSTRUCT
),
627 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
628 ok(test
.nErrCode
== ERROR_SUCCESS
, "LZOpenFileW set test.nErrCode to %d\n",
630 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
631 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
632 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
633 test
.szPathName
, expected
);
636 memset(&test
, 0xA5, sizeof(test
));
637 full_file_path_name_in_a_CWD(_terminated_
, expected
, FALSE
);
639 /* d, using underscore-terminated file name. */
640 file
= LZOpenFileW(_terminatedW
, &test
, OF_EXIST
);
641 ok(file
>= 0, "LZOpenFileW failed on switching to a compressed file name\n");
642 ok(test
.cBytes
== sizeof(OFSTRUCT
),
643 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
644 ok(test
.nErrCode
== ERROR_SUCCESS
, "LZOpenFileW set test.nErrCode to %d\n",
646 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
647 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
648 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
649 test
.szPathName
, expected
);
652 delete_fileW(filenameW_
);
653 delete_fileW(dotlessW_
);
654 delete_fileW(extlessW_
);
655 delete_fileW(_terminatedW_
);
658 static void test_LZOpenFileW_nonexisting_compressed(void)
662 char expected
[MAX_PATH
];
663 char filled_0xA5
[OFS_MAXPATHNAME
];
665 /* Try to open nonexisting compressed files: */
666 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
667 memset(&test
, 0xA5, sizeof(test
));
668 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
669 SetLastError(0xfaceabee);
671 /* a, using 8.3-conformant file name. */
672 file
= LZOpenFileW(filenameW
, &test
, OF_EXIST
);
673 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
674 check for the file "foo.xx_" and open that -- at least on some
675 operating systems. Doesn't seem to on my copy of Win98.
677 ok(file
== LZERROR_BADINHANDLE
,
678 "LZOpenFileW succeeded on nonexistent file\n");
679 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
680 "GetLastError() returns %ld\n", GetLastError());
682 ok(test
.cBytes
== 0xA5,
683 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
684 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
685 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
686 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
687 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
688 test
.szPathName
, expected
, filled_0xA5
);
690 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
691 memset(&test
, 0xA5, sizeof(test
));
692 full_file_path_name_in_a_CWD(dotless_
, expected
, FALSE
);
693 SetLastError(0xfaceabee);
695 /* b, using dotless file name. */
696 file
= LZOpenFileW(dotlessW
, &test
, OF_EXIST
);
697 ok(file
== LZERROR_BADINHANDLE
,
698 "LZOpenFileW succeeded on nonexistent file\n");
699 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
700 "GetLastError() returns %ld\n", GetLastError());
702 ok(test
.cBytes
== 0xA5,
703 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
704 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
705 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
706 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
707 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
708 test
.szPathName
, expected
, filled_0xA5
);
710 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
711 memset(&test
, 0xA5, sizeof(test
));
712 full_file_path_name_in_a_CWD(extless_
, expected
, FALSE
);
713 SetLastError(0xfaceabee);
715 /* c, using extensionless file name. */
716 file
= LZOpenFileW(extlessW
, &test
, OF_EXIST
);
717 ok(file
== LZERROR_BADINHANDLE
,
718 "LZOpenFileW succeeded on nonexistent file\n");
719 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
720 "GetLastError() returns %ld\n", GetLastError());
722 ok(test
.cBytes
== 0xA5,
723 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
724 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
725 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
726 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
727 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
728 test
.szPathName
, expected
, filled_0xA5
);
730 memset(&filled_0xA5
, 0xA5, OFS_MAXPATHNAME
);
731 memset(&test
, 0xA5, sizeof(test
));
732 full_file_path_name_in_a_CWD(_terminated_
, expected
, FALSE
);
733 SetLastError(0xfaceabee);
735 /* d, using underscore-terminated file name. */
736 file
= LZOpenFileW(_terminatedW
, &test
, OF_EXIST
);
737 ok(file
== LZERROR_BADINHANDLE
,
738 "LZOpenFileW succeeded on nonexistent file\n");
739 ok(GetLastError() == ERROR_FILE_NOT_FOUND
,
740 "GetLastError() returns %ld\n", GetLastError());
742 ok(test
.cBytes
== 0xA5,
743 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
744 ok(test
.nErrCode
== ERROR_FILE_NOT_FOUND
,
745 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
746 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
747 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
748 test
.szPathName
, expected
, filled_0xA5
);
751 static void test_LZOpenFileW(void)
756 static WCHAR badfilenameW
[] = {'b','a','d','f','i','l','e','n','a','m','e','.','x','t','n',0};
757 char expected
[MAX_PATH
];
759 SetLastError(0xfaceabee);
760 /* Check for nonexistent file. */
761 file
= LZOpenFileW(badfilenameW
, &test
, OF_READ
);
762 ok(GetLastError() == ERROR_FILE_NOT_FOUND
|| GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
763 "GetLastError() returns %ld\n", GetLastError());
764 if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
766 trace("LZOpenFileW call not implemented, skipping rest of the test\n");
769 ok(file
== LZERROR_BADINHANDLE
, "LZOpenFileW succeeded on nonexistent file\n");
772 memset(&test
, 0xA5, sizeof(test
));
773 full_file_path_name_in_a_CWD(filename_
, expected
, FALSE
);
775 /* Create an empty file. */
776 file
= LZOpenFileW(filenameW_
, &test
, OF_CREATE
);
777 ok(file
>= 0, "LZOpenFile failed on creation\n");
778 ok(test
.cBytes
== sizeof(OFSTRUCT
),
779 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
780 ok(test
.nErrCode
== ERROR_SUCCESS
,
781 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
782 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
783 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
784 test
.szPathName
, expected
);
787 retval
= GetFileAttributesW(filenameW_
);
788 ok(retval
!= INVALID_FILE_ATTRIBUTES
, "GetFileAttributes: error %ld\n",
791 /* Check various opening options: */
792 memset(&test
, 0xA5, sizeof(test
));
794 /* a, for reading. */
795 file
= LZOpenFileW(filenameW_
, &test
, OF_READ
);
796 ok(file
>= 0, "LZOpenFileW failed on read\n");
797 ok(test
.cBytes
== sizeof(OFSTRUCT
),
798 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
799 ok(test
.nErrCode
== ERROR_SUCCESS
,
800 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
801 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
802 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
803 test
.szPathName
, expected
);
806 memset(&test
, 0xA5, sizeof(test
));
808 /* b, for writing. */
809 file
= LZOpenFileW(filenameW_
, &test
, OF_WRITE
);
810 ok(file
>= 0, "LZOpenFileW failed on write\n");
811 ok(test
.cBytes
== sizeof(OFSTRUCT
),
812 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
813 ok(test
.nErrCode
== ERROR_SUCCESS
,
814 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
815 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
816 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
817 test
.szPathName
, expected
);
820 memset(&test
, 0xA5, sizeof(test
));
822 /* c, for reading and writing. */
823 file
= LZOpenFileW(filenameW_
, &test
, OF_READWRITE
);
824 ok(file
>= 0, "LZOpenFileW failed on read/write\n");
825 ok(test
.cBytes
== sizeof(OFSTRUCT
),
826 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
827 ok(test
.nErrCode
== ERROR_SUCCESS
,
828 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
829 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
830 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
831 test
.szPathName
, expected
);
834 memset(&test
, 0xA5, sizeof(test
));
836 /* d, for checking file existance. */
837 file
= LZOpenFileW(filenameW_
, &test
, OF_EXIST
);
838 ok(file
>= 0, "LZOpenFileW failed on read/write\n");
839 ok(test
.cBytes
== sizeof(OFSTRUCT
),
840 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
841 ok(test
.nErrCode
== ERROR_SUCCESS
,
842 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
843 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
844 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
845 test
.szPathName
, expected
);
848 memset(&test
, 0xA5, sizeof(test
));
850 /* Delete the file then make sure it doesn't exist anymore. */
851 file
= LZOpenFileW(filenameW_
, &test
, OF_DELETE
);
852 ok(file
>= 0, "LZOpenFileW failed on delete\n");
853 ok(test
.cBytes
== sizeof(OFSTRUCT
),
854 "LZOpenFileW set test.cBytes to %d\n", test
.cBytes
);
855 ok(test
.nErrCode
== ERROR_SUCCESS
,
856 "LZOpenFileW set test.nErrCode to %d\n", test
.nErrCode
);
857 ok(lstrcmpA(test
.szPathName
, expected
) == 0,
858 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
859 test
.szPathName
, expected
);
862 retval
= GetFileAttributesW(filenameW_
);
863 ok(retval
== INVALID_FILE_ATTRIBUTES
,
864 "GetFileAttributesW succeeded on deleted file\n");
866 test_LZOpenFileW_existing_compressed();
867 test_LZOpenFileW_nonexisting_compressed();
871 START_TEST(lzexpand_main
)
873 buf
= malloc(uncompressed_data_size
* 2);