ReactOS 0.4.16-dev-1489-g8fbbb41
lzexpand_main.c
Go to the documentation of this file.
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. */
31static char filename [] = "testfile.xxx";
32static char filename_[] = "testfile.xx_";
33static WCHAR filenameW [] = {'t','e','s','t','f','i','l','e','.','x','x','x',0};
34static WCHAR filenameW_[] = {'t','e','s','t','f','i','l','e','.','x','x','_',0};
35
36static char dotless [] = "dotless";
37static char dotless_[] = "dotless._";
38static WCHAR dotlessW [] = {'d','o','t','l','e','s','s', 0};
39static WCHAR dotlessW_[] = {'d','o','t','l','e','s','s','.','_', 0};
40
41static char extless [] = "extless.";
42static char extless_[] = "extless._";
43static WCHAR extlessW [] = {'e','x','t','l','e','s','s','.', 0};
44static WCHAR extlessW_[] = {'e','x','t','l','e','s','s','.','_', 0};
45
46static char _terminated [] = "_terminated.xxxx_";
47static char _terminated_[] = "_terminated.xxxx_";
48static WCHAR _terminatedW [] = {'_','t','e','r','m','i','n','a','t','e','d','.','x','x','x','x','_', 0};
49static WCHAR _terminatedW_[] = {'_','t','e','r','m','i','n','a','t','e','d','.','x','x','x','x','_', 0};
50
51static 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.
58 */
59static const unsigned char compressed_file[] =
60 {0x53,0x5A,0x44,0x44,0x88,0xF0,0x27,0x33,0x41,
61 0x74,0x75,0x14,0x00,0x00,0xDF,0x54,0x68,0x69,
62 0x73,0x20,0xF2,0xF0,0x61,0x20,0xFF,0x74,0x65,
63 0x73,0x74,0x20,0x66,0x69,0x6C,0x03,0x65,0x2E};
64static const DWORD compressed_file_size = sizeof(compressed_file);
65
66static const char uncompressed_data[] = "This is a test file.";
67static const DWORD uncompressed_data_size = sizeof(uncompressed_data) - 1;
68
69static char *buf;
70
71static void full_file_path_name_in_a_CWD(const char *src, char *dst, BOOL expect_short)
72{
73 DWORD retval;
74 char shortname[MAX_PATH];
75
76 retval = GetCurrentDirectoryA(MAX_PATH, dst);
77 ok(retval > 0, "GetCurrentDirectoryA returned %d, GLE=%d\n",
78 retval, GetLastError());
79 if(dst[retval-1] != '\\')
80 /* Append backslash only when it's missing */
81 lstrcatA(dst, "\\");
82 lstrcatA(dst, src);
83 if(expect_short)
84 {
85 memcpy(shortname, dst, MAX_PATH);
86 retval = GetShortPathNameA(shortname, dst, MAX_PATH-1);
87 ok(retval > 0, "GetShortPathNameA returned %d for '%s', GLE=%d\n",
88 retval, dst, GetLastError());
89 }
90}
91
92static void create_file(char *fname)
93{
94 INT file;
95 OFSTRUCT ofs;
96 DWORD retval;
97
98 file = LZOpenFileA(fname, &ofs, OF_CREATE);
99 ok(file >= 0, "LZOpenFileA failed to create '%s'\n", fname);
100 LZClose(file);
101 retval = GetFileAttributesA(fname);
102 ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA('%s'): error %d\n", ofs.szPathName, GetLastError());
103}
104
105static void delete_file(char *fname)
106{
107 INT file;
108 OFSTRUCT ofs;
109 DWORD retval;
110
111 file = LZOpenFileA(fname, &ofs, OF_DELETE);
112 ok(file >= 0, "LZOpenFileA failed to delete '%s'\n", fname);
113 LZClose(file);
114 retval = GetFileAttributesA(fname);
115 ok(retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file ('%s')\n", ofs.szPathName);
116}
117
118static void test_LZOpenFileA_existing_compressed(void)
119{
120 OFSTRUCT test;
121 INT file;
122 char expected[MAX_PATH];
123 char short_expected[MAX_PATH];
124 char filled_0xA5[OFS_MAXPATHNAME];
125
126 /* Try to open existing compressed files: */
127 create_file(filename_);
128 create_file(dotless_);
129 create_file(extless_);
130 create_file(_terminated_);
131
132 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
133 memset(&test, 0xA5, sizeof(test));
134 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
135 SetLastError(0xfaceabee);
136
137 /* a, using 8.3-conformant file name. */
138 file = LZOpenFileA(filename, &test, OF_EXIST);
139 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
140 check for the file "foo.xx_" and open that -- at least on some
141 operating systems. Doesn't seem to on my copy of Win98.
142 */
143 ok(file >= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", filename);
144 ok(test.cBytes == sizeof(OFSTRUCT),
145 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
146 ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
147 test.nErrCode);
148 ok(lstrcmpA(test.szPathName, expected) == 0,
149 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
150 test.szPathName, expected);
151 LZClose(file);
152
153 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
154 memset(&test, 0xA5, sizeof(test));
155 full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
156 SetLastError(0xfaceabee);
157
158 /* b, using dotless file name. */
159 file = LZOpenFileA(dotless, &test, OF_EXIST);
160 ok(file >= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", dotless);
161 ok(test.cBytes == sizeof(OFSTRUCT),
162 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
163 ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
164 test.nErrCode);
165 ok(lstrcmpA(test.szPathName, expected) == 0,
166 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
167 test.szPathName, expected);
168 LZClose(file);
169
170 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
171 memset(&test, 0xA5, sizeof(test));
172 full_file_path_name_in_a_CWD(extless_, expected, FALSE);
173 SetLastError(0xfaceabee);
174
175 /* c, using extensionless file name. */
176 file = LZOpenFileA(extless, &test, OF_EXIST);
177 ok(file >= 0, "LZOpenFileA returns negative file descriptor for '%s'\n", extless);
178 ok(test.cBytes == sizeof(OFSTRUCT),
179 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
180 ok(test.nErrCode == 0, "LZOpenFileA set test.nErrCode to %d\n",
181 test.nErrCode);
182 ok(lstrcmpA(test.szPathName, expected) == 0,
183 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
184 test.szPathName, expected);
185 LZClose(file);
186
187 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
188 memset(&test, 0xA5, sizeof(test));
189 full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
190 full_file_path_name_in_a_CWD(_terminated_, short_expected, TRUE);
191
192 /* d, using underscore-terminated file name. */
193 file = LZOpenFileA(_terminated, &test, OF_EXIST);
194 ok(file >= 0, "LZOpenFileA failed on switching to a compressed file name\n");
195 ok(test.cBytes == sizeof(OFSTRUCT), "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' or '%s'\n",
200 test.szPathName, expected, short_expected);
201 LZClose(file);
202
203 delete_file(filename_);
204 delete_file(dotless_);
205 delete_file(extless_);
206 delete_file(_terminated_);
207}
208
209static void test_LZOpenFileA_nonexisting_compressed(void)
210{
211 OFSTRUCT test;
212 INT file;
213 char expected[MAX_PATH];
214 char filled_0xA5[OFS_MAXPATHNAME];
215
216 /* Try to open nonexisting compressed files: */
217 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
218 memset(&test, 0xA5, sizeof(test));
219 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
220 SetLastError(0xfaceabee);
221
222 /* a, using 8.3-conformant file name. */
223 file = LZOpenFileA(filename, &test, OF_EXIST);
224 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
225 check for the file "foo.xx_" and open that -- at least on some
226 operating systems. Doesn't seem to on my copy of Win98.
227 */
228 ok(file == LZERROR_BADINHANDLE,
229 "LZOpenFileA succeeded on nonexistent file\n");
230 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
231 "GetLastError() returns %d\n", GetLastError());
232 ok(test.cBytes == 0xA5,
233 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
234 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
235 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
236 ok(lstrcmpA(test.szPathName, expected) == 0,
237 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
238 test.szPathName, expected, filled_0xA5);
239
240 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
241 memset(&test, 0xA5, sizeof(test));
242 full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
243 SetLastError(0xfaceabee);
244
245 /* b, using dotless file name. */
246 file = LZOpenFileA(dotless, &test, OF_EXIST);
247 ok(file == LZERROR_BADINHANDLE,
248 "LZOpenFileA succeeded on nonexistent file\n");
249 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
250 "GetLastError() returns %d\n", GetLastError());
251 ok(test.cBytes == 0xA5,
252 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
253 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
254 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
255 ok(lstrcmpA(test.szPathName, expected) == 0,
256 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
257 test.szPathName, expected, filled_0xA5);
258
259 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
260 memset(&test, 0xA5, sizeof(test));
261 full_file_path_name_in_a_CWD(extless_, expected, FALSE);
262 SetLastError(0xfaceabee);
263
264 /* c, using extensionless file name. */
265 file = LZOpenFileA(extless, &test, OF_EXIST);
266 ok(file == LZERROR_BADINHANDLE,
267 "LZOpenFileA succeeded on nonexistent file\n");
268 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
269 "GetLastError() returns %d\n", GetLastError());
270 ok(test.cBytes == 0xA5,
271 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
272 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
273 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
274 ok(lstrcmpA(test.szPathName, expected) == 0,
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(_terminated_, expected, FALSE);
281 SetLastError(0xfaceabee);
282
283 /* d, using underscore-terminated file name. */
284 file = LZOpenFileA(_terminated, &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 %d\n", GetLastError());
289 ok(test.cBytes == 0xA5,
290 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
291 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
292 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
293 ok(lstrcmpA(test.szPathName, expected) == 0,
294 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
295 test.szPathName, expected, filled_0xA5);
296}
297
298static void test_LZOpenFileA(void)
299{
300 OFSTRUCT test;
301 DWORD retval;
302 INT file;
303 static char badfilename_[] = "badfilename_";
304 char expected[MAX_PATH];
305 char short_expected[MAX_PATH];
306
307 SetLastError(0xfaceabee);
308 /* Check for nonexistent file. */
309 file = LZOpenFileA(badfilename_, &test, OF_READ);
310 ok(file == LZERROR_BADINHANDLE,
311 "LZOpenFileA succeeded on nonexistent file\n");
312 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
313 "GetLastError() returns %d\n", GetLastError());
314 LZClose(file);
315
316 memset(&test, 0xA5, sizeof(test));
317 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
318
319 /* Create an empty file. */
320 file = LZOpenFileA(filename_, &test, OF_CREATE);
321 ok(file >= 0, "LZOpenFileA failed on creation\n");
322 ok(test.cBytes == sizeof(OFSTRUCT),
323 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
324 ok(test.nErrCode == ERROR_SUCCESS,
325 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
326 ok(lstrcmpA(test.szPathName, expected) == 0,
327 "LZOpenFileA returned '%s', but was expected to return '%s'\n",
328 test.szPathName, expected);
329 LZClose(file);
330
331 retval = GetFileAttributesA(filename_);
332 ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %d\n",
333 GetLastError());
334
335 /* Check various opening options: */
336 memset(&test, 0xA5, sizeof(test));
337 full_file_path_name_in_a_CWD(filename_, short_expected, TRUE);
338
339 /* a, for reading. */
340 file = LZOpenFileA(filename_, &test, OF_READ);
341 ok(file >= 0, "LZOpenFileA failed on read\n");
342 ok(test.cBytes == sizeof(OFSTRUCT),
343 "LZOpenFileA set test.cBytes to %d '%s'('%s')\n", test.cBytes, expected, short_expected);
344 ok(test.nErrCode == ERROR_SUCCESS,
345 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
346 ok(lstrcmpA(test.szPathName, expected) == 0,
347 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
348 test.szPathName, expected, short_expected);
349 LZClose(file);
350
351 memset(&test, 0xA5, sizeof(test));
352
353 /* b, for writing. */
354 file = LZOpenFileA(filename_, &test, OF_WRITE);
355 ok(file >= 0, "LZOpenFileA failed on write\n");
356 ok(test.cBytes == sizeof(OFSTRUCT),
357 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
358 ok(test.nErrCode == ERROR_SUCCESS,
359 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
360 ok(lstrcmpA(test.szPathName, expected) == 0,
361 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
362 test.szPathName, expected, short_expected);
363 LZClose(file);
364
365 memset(&test, 0xA5, sizeof(test));
366
367 /* c, for reading and writing. */
368 file = LZOpenFileA(filename_, &test, OF_READWRITE);
369 ok(file >= 0, "LZOpenFileA failed on read/write\n");
370 ok(test.cBytes == sizeof(OFSTRUCT),
371 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
372 ok(test.nErrCode == ERROR_SUCCESS,
373 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
374 ok(lstrcmpA(test.szPathName, expected) == 0,
375 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
376 test.szPathName, expected, short_expected);
377 LZClose(file);
378
379 memset(&test, 0xA5, sizeof(test));
380
381 /* d, for checking file existence. */
382 file = LZOpenFileA(filename_, &test, OF_EXIST);
383 ok(file >= 0, "LZOpenFileA failed on read/write\n");
384 ok(test.cBytes == sizeof(OFSTRUCT),
385 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
386 ok(test.nErrCode == ERROR_SUCCESS,
387 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
388 ok(lstrcmpA(test.szPathName, expected) == 0,
389 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
390 test.szPathName, expected, short_expected);
391 LZClose(file);
392
393 memset(&test, 0xA5, sizeof(test));
394
395 /* Delete the file then make sure it doesn't exist anymore. */
396 file = LZOpenFileA(filename_, &test, OF_DELETE);
397 ok(file >= 0, "LZOpenFileA failed on delete\n");
398 ok(test.cBytes == sizeof(OFSTRUCT),
399 "LZOpenFileA set test.cBytes to %d\n", test.cBytes);
400 ok(test.nErrCode == ERROR_SUCCESS,
401 "LZOpenFileA set test.nErrCode to %d\n", test.nErrCode);
402 ok(lstrcmpA(test.szPathName, expected) == 0,
403 "LZOpenFileA returned '%s', but was expected to return '%s' or '%s'\n",
404 test.szPathName, expected, short_expected);
405 LZClose(file);
406
407 retval = GetFileAttributesA(filename_);
408 ok(retval == INVALID_FILE_ATTRIBUTES,
409 "GetFileAttributesA succeeded on deleted file\n");
410
411 test_LZOpenFileA_existing_compressed();
412 test_LZOpenFileA_nonexisting_compressed();
413}
414
415static void test_LZRead(void)
416{
417 HANDLE file;
418 DWORD ret;
419 int cfile;
420 OFSTRUCT test;
421 BOOL retok;
422
423 /* Create the compressed file. */
424 file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
425 ok(file != INVALID_HANDLE_VALUE, "Could not create test file\n");
426 retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
427 ok( retok, "WriteFile: error %d\n", GetLastError());
428 ok(ret == compressed_file_size, "Wrote wrong number of bytes with WriteFile?\n");
429 CloseHandle(file);
430
431 cfile = LZOpenFileA(filename_, &test, OF_READ);
432 ok(cfile > 0, "LZOpenFileA failed\n");
433
434 ret = LZRead(cfile, buf, uncompressed_data_size);
435 ok(ret == uncompressed_data_size, "Read wrong number of bytes\n");
436
437 /* Compare what we read with what we think we should read. */
438 ok(memcmp(buf, uncompressed_data, uncompressed_data_size) == 0,
439 "buffer contents mismatch\n");
440
441 todo_wine {
442 /* Wine returns the number of bytes actually read instead of an error */
443 ret = LZRead(cfile, buf, uncompressed_data_size);
444 ok(ret == LZERROR_READ, "Expected read-past-EOF to return LZERROR_READ\n");
445 }
446
447 LZClose(cfile);
448
449 ret = DeleteFileA(filename_);
450 ok(ret, "DeleteFileA: error %d\n", GetLastError());
451}
452
453static void test_LZCopy(void)
454{
455 HANDLE file;
456 DWORD ret;
457 int source, dest;
458 OFSTRUCT stest, dtest;
459 BOOL retok;
460
461 /* Create the compressed file. */
462 file = CreateFileA(filename_, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0);
463 ok(file != INVALID_HANDLE_VALUE,
464 "CreateFileA: error %d\n", GetLastError());
465 retok = WriteFile(file, compressed_file, compressed_file_size, &ret, 0);
466 ok( retok, "WriteFile error %d\n", GetLastError());
467 ok(ret == compressed_file_size, "Wrote wrong number of bytes\n");
468 CloseHandle(file);
469
470 source = LZOpenFileA(filename_, &stest, OF_READ);
471 ok(source >= 0, "LZOpenFileA failed on compressed file\n");
472 dest = LZOpenFileA(filename2, &dtest, OF_CREATE);
473 ok(dest >= 0, "LZOpenFileA failed on creating new file %d\n", dest);
474
475 ret = LZCopy(source, dest);
476 ok(ret > 0, "LZCopy error\n");
477
478 LZClose(source);
479 LZClose(dest);
480
481 file = CreateFileA(filename2, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
482 ok(file != INVALID_HANDLE_VALUE,
483 "CreateFileA: error %d\n", GetLastError());
484
485 retok = ReadFile(file, buf, uncompressed_data_size*2, &ret, 0);
486 ok( retok && ret == uncompressed_data_size, "ReadFile: error %d\n", GetLastError());
487 /* Compare what we read with what we think we should read. */
488 ok(!memcmp(buf, uncompressed_data, uncompressed_data_size),
489 "buffer contents mismatch\n");
490 CloseHandle(file);
491
492 ret = DeleteFileA(filename_);
493 ok(ret, "DeleteFileA: error %d\n", GetLastError());
494 ret = DeleteFileA(filename2);
495 ok(ret, "DeleteFileA: error %d\n", GetLastError());
496}
497
498static void create_fileW(WCHAR *fnameW)
499{
500 INT file;
501 OFSTRUCT ofs;
502 DWORD retval;
503
504 file = LZOpenFileW(fnameW, &ofs, OF_CREATE);
505 ok(file >= 0, "LZOpenFileW failed on creation\n");
506 LZClose(file);
507 retval = GetFileAttributesW(fnameW);
508 ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesW('%s'): error %d\n", ofs.szPathName, GetLastError());
509}
510
511static void delete_fileW(WCHAR *fnameW)
512{
513 INT file;
514 OFSTRUCT ofs;
515 DWORD retval;
516
517 file = LZOpenFileW(fnameW, &ofs, OF_DELETE);
518 ok(file >= 0, "LZOpenFileW failed on delete\n");
519 LZClose(file);
520 retval = GetFileAttributesW(fnameW);
521 ok(retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesW succeeded on deleted file ('%s')\n", ofs.szPathName);
522}
523
524static void test_LZOpenFileW_existing_compressed(void)
525{
526 OFSTRUCT test;
527 INT file;
528 char expected[MAX_PATH];
529
530 /* Try to open existing compressed files: */
531 create_fileW(filenameW_);
532 create_fileW(dotlessW_);
533 create_fileW(extlessW_);
534 create_fileW(_terminatedW_);
535
536 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
537 memset(&test, 0xA5, sizeof(test));
538
539 /* a, using 8.3-conformant file name. */
540 file = LZOpenFileW(filenameW, &test, OF_EXIST);
541 /* If the file "foo.xxx" does not exist, LZOpenFileW should then
542 check for the file "foo.xx_" and open that.
543 */
544 ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
545 ok(test.cBytes == sizeof(OFSTRUCT),
546 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
547 ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
548 test.nErrCode);
549 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
550 ok(lstrcmpA(test.szPathName, expected) == 0,
551 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
552 test.szPathName, expected);
553 LZClose(file);
554
555 memset(&test, 0xA5, sizeof(test));
556 full_file_path_name_in_a_CWD(dotless_, expected, FALSE);
557
558 /* b, using dotless file name. */
559 file = LZOpenFileW(dotlessW, &test, OF_EXIST);
560 ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
561 ok(test.cBytes == sizeof(OFSTRUCT),
562 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
563 ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
564 test.nErrCode);
565 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
566 ok(lstrcmpA(test.szPathName, expected) == 0,
567 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
568 test.szPathName, expected);
569 LZClose(file);
570
571 memset(&test, 0xA5, sizeof(test));
572 full_file_path_name_in_a_CWD(extless_, expected, FALSE);
573
574 /* c, using extensionless file name. */
575 file = LZOpenFileW(extlessW, &test, OF_EXIST);
576 ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
577 ok(test.cBytes == sizeof(OFSTRUCT),
578 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
579 ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
580 test.nErrCode);
581 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
582 ok(lstrcmpA(test.szPathName, expected) == 0,
583 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
584 test.szPathName, expected);
585 LZClose(file);
586
587 memset(&test, 0xA5, sizeof(test));
588 full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
589
590 /* d, using underscore-terminated file name. */
591 file = LZOpenFileW(_terminatedW, &test, OF_EXIST);
592 ok(file >= 0, "LZOpenFileW failed on switching to a compressed file name\n");
593 ok(test.cBytes == sizeof(OFSTRUCT),
594 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
595 ok(test.nErrCode == ERROR_SUCCESS, "LZOpenFileW set test.nErrCode to %d\n",
596 test.nErrCode);
597 /* Note that W-function returns A-string by a OFSTRUCT.szPathName: */
598 ok(lstrcmpA(test.szPathName, expected) == 0,
599 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
600 test.szPathName, expected);
601 LZClose(file);
602
603 delete_fileW(filenameW_);
604 delete_fileW(dotlessW_);
605 delete_fileW(extlessW_);
606 delete_fileW(_terminatedW_);
607}
608
609static void test_LZOpenFileW_nonexisting_compressed(void)
610{
611 OFSTRUCT test;
612 INT file;
613 char expected[MAX_PATH];
614 char filled_0xA5[OFS_MAXPATHNAME];
615
616 /* Try to open nonexisting compressed files: */
617 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
618 memset(&test, 0xA5, sizeof(test));
619 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
620 SetLastError(0xfaceabee);
621
622 /* a, using 8.3-conformant file name. */
623 file = LZOpenFileW(filenameW, &test, OF_EXIST);
624 /* If the file "foo.xxx" does not exist, LZOpenFileA should then
625 check for the file "foo.xx_" and open that -- at least on some
626 operating systems. Doesn't seem to on my copy of Win98.
627 */
628 ok(file == LZERROR_BADINHANDLE,
629 "LZOpenFileW succeeded on nonexistent file\n");
630 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
631 "GetLastError() returns %d\n", GetLastError());
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(dotless_, expected, FALSE);
643 SetLastError(0xfaceabee);
644
645 /* b, using dotless file name. */
646 file = LZOpenFileW(dotlessW, &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 %d\n", GetLastError());
651 ok(test.cBytes == 0xA5,
652 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
653 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
654 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
655 ok(lstrcmpA(test.szPathName, expected) == 0,
656 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
657 test.szPathName, expected, filled_0xA5);
658
659 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
660 memset(&test, 0xA5, sizeof(test));
661 full_file_path_name_in_a_CWD(extless_, expected, FALSE);
662 SetLastError(0xfaceabee);
663
664 /* c, using extensionless file name. */
665 file = LZOpenFileW(extlessW, &test, OF_EXIST);
666 ok(file == LZERROR_BADINHANDLE,
667 "LZOpenFileW succeeded on nonexistent file\n");
668 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
669 "GetLastError() returns %d\n", GetLastError());
670 ok(test.cBytes == 0xA5,
671 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
672 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
673 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
674 ok(lstrcmpA(test.szPathName, expected) == 0,
675 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
676 test.szPathName, expected, filled_0xA5);
677
678 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
679 memset(&test, 0xA5, sizeof(test));
680 full_file_path_name_in_a_CWD(_terminated_, expected, FALSE);
681 SetLastError(0xfaceabee);
682
683 /* d, using underscore-terminated file name. */
684 file = LZOpenFileW(_terminatedW, &test, OF_EXIST);
685 ok(file == LZERROR_BADINHANDLE,
686 "LZOpenFileW succeeded on nonexistent file\n");
687 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
688 "GetLastError() returns %d\n", GetLastError());
689 ok(test.cBytes == 0xA5,
690 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
691 ok(test.nErrCode == ERROR_FILE_NOT_FOUND,
692 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
693 ok(lstrcmpA(test.szPathName, expected) == 0,
694 "LZOpenFileW returned '%s', but was expected to return '%s' or '%s'\n",
695 test.szPathName, expected, filled_0xA5);
696}
697
698static void test_LZOpenFileW(void)
699{
700 OFSTRUCT test;
701 DWORD retval;
702 INT file;
703 static WCHAR badfilenameW[] = {'b','a','d','f','i','l','e','n','a','m','e','.','x','t','n',0};
704 char expected[MAX_PATH];
705
706 SetLastError(0xfaceabee);
707 /* Check for nonexistent file. */
708 file = LZOpenFileW(badfilenameW, &test, OF_READ);
709 if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
710 {
711 win_skip("LZOpenFileW call is not implemented\n");
712 return;
713 }
714 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
715 "GetLastError() returns %d\n", GetLastError());
716 ok(file == LZERROR_BADINHANDLE, "LZOpenFileW succeeded on nonexistent file\n");
717 LZClose(file);
718
719 memset(&test, 0xA5, sizeof(test));
720 full_file_path_name_in_a_CWD(filename_, expected, FALSE);
721
722 /* Create an empty file. */
723 file = LZOpenFileW(filenameW_, &test, OF_CREATE);
724 ok(file >= 0, "LZOpenFile failed on creation\n");
725 ok(test.cBytes == sizeof(OFSTRUCT),
726 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
727 ok(test.nErrCode == ERROR_SUCCESS,
728 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
729 ok(lstrcmpA(test.szPathName, expected) == 0,
730 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
731 test.szPathName, expected);
732 LZClose(file);
733
734 retval = GetFileAttributesW(filenameW_);
735 ok(retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributes: error %d\n",
736 GetLastError());
737
738 /* Check various opening options: */
739 memset(&test, 0xA5, sizeof(test));
740
741 /* a, for reading. */
742 file = LZOpenFileW(filenameW_, &test, OF_READ);
743 ok(file >= 0, "LZOpenFileW failed on read\n");
744 ok(test.cBytes == sizeof(OFSTRUCT),
745 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
746 ok(test.nErrCode == ERROR_SUCCESS,
747 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
748 ok(lstrcmpA(test.szPathName, expected) == 0,
749 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
750 test.szPathName, expected);
751 LZClose(file);
752
753 memset(&test, 0xA5, sizeof(test));
754
755 /* b, for writing. */
756 file = LZOpenFileW(filenameW_, &test, OF_WRITE);
757 ok(file >= 0, "LZOpenFileW failed on write\n");
758 ok(test.cBytes == sizeof(OFSTRUCT),
759 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
760 ok(test.nErrCode == ERROR_SUCCESS,
761 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
762 ok(lstrcmpA(test.szPathName, expected) == 0,
763 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
764 test.szPathName, expected);
765 LZClose(file);
766
767 memset(&test, 0xA5, sizeof(test));
768
769 /* c, for reading and writing. */
770 file = LZOpenFileW(filenameW_, &test, OF_READWRITE);
771 ok(file >= 0, "LZOpenFileW failed on read/write\n");
772 ok(test.cBytes == sizeof(OFSTRUCT),
773 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
774 ok(test.nErrCode == ERROR_SUCCESS,
775 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
776 ok(lstrcmpA(test.szPathName, expected) == 0,
777 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
778 test.szPathName, expected);
779 LZClose(file);
780
781 memset(&test, 0xA5, sizeof(test));
782
783 /* d, for checking file existence. */
784 file = LZOpenFileW(filenameW_, &test, OF_EXIST);
785 ok(file >= 0, "LZOpenFileW failed on read/write\n");
786 ok(test.cBytes == sizeof(OFSTRUCT),
787 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
788 ok(test.nErrCode == ERROR_SUCCESS,
789 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
790 ok(lstrcmpA(test.szPathName, expected) == 0,
791 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
792 test.szPathName, expected);
793 LZClose(file);
794
795 memset(&test, 0xA5, sizeof(test));
796
797 /* Delete the file then make sure it doesn't exist anymore. */
798 file = LZOpenFileW(filenameW_, &test, OF_DELETE);
799 ok(file >= 0, "LZOpenFileW failed on delete\n");
800 ok(test.cBytes == sizeof(OFSTRUCT),
801 "LZOpenFileW set test.cBytes to %d\n", test.cBytes);
802 ok(test.nErrCode == ERROR_SUCCESS,
803 "LZOpenFileW set test.nErrCode to %d\n", test.nErrCode);
804 ok(lstrcmpA(test.szPathName, expected) == 0,
805 "LZOpenFileW returned '%s', but was expected to return '%s'\n",
806 test.szPathName, expected);
807 LZClose(file);
808
809 retval = GetFileAttributesW(filenameW_);
810 ok(retval == INVALID_FILE_ATTRIBUTES,
811 "GetFileAttributesW succeeded on deleted file\n");
812
813 test_LZOpenFileW_existing_compressed();
814 test_LZOpenFileW_nonexisting_compressed();
815}
816
817
818START_TEST(lzexpand_main)
819{
820 buf = HeapAlloc(GetProcessHeap(), 0, uncompressed_data_size * 2);
821 test_LZOpenFileA();
822 test_LZOpenFileW();
823 test_LZRead();
824 test_LZCopy();
825 HeapFree(GetProcessHeap(), 0, buf);
826}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
CloseHandle
#define CloseHandle
Definition: compat.h:739
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
ERROR_CALL_NOT_IMPLEMENTED
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
ReadFile
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
SetLastError
#define SetLastError(x)
Definition: compat.h:752
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
CreateFileA
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
DeleteFileA
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
GetFileAttributesW
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
GetFileAttributesA
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:636
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
GetCurrentDirectoryA
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2146
GetShortPathNameA
DWORD WINAPI GetShortPathNameA(IN LPCSTR lpszLongPath, OUT LPSTR lpszShortPath, IN DWORD cchBuffer)
Definition: path.c:1752
lstrcmpA
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4198
ret
return ret
Definition: mutex.c:146
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
src
GLenum src
Definition: glext.h:6340
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
dst
GLenum GLenum dst
Definition: glext.h:6340
filename
const char * filename
Definition: ioapi.h:137
lstrcatA
LPSTR WINAPI lstrcatA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:123
LZRead
INT WINAPI LZRead(HFILE fd, LPSTR vbuf, INT toread)
Definition: lzexpand.c:345
LZOpenFileW
HFILE WINAPI LZOpenFileW(LPWSTR fn, LPOFSTRUCT ofs, WORD mode)
Definition: lzexpand.c:580
LZCopy
LONG WINAPI LZCopy(HFILE src, HFILE dest)
Definition: lzexpand.c:467
LZClose
void WINAPI LZClose(HFILE fd)
Definition: lzexpand.c:595
LZOpenFileA
HFILE WINAPI LZOpenFileA(LPSTR fn, LPOFSTRUCT ofs, WORD mode)
Definition: lzexpand.c:551
LZERROR_READ
#define LZERROR_READ
Definition: lzexpand.h:9
LZERROR_BADINHANDLE
#define LZERROR_BADINHANDLE
Definition: lzexpand.h:7
_terminated
static char _terminated[]
Definition: lzexpand_main.c:46
filenameW
static WCHAR filenameW[]
Definition: lzexpand_main.c:33
extlessW_
static WCHAR extlessW_[]
Definition: lzexpand_main.c:44
test_LZOpenFileA_nonexisting_compressed
static void test_LZOpenFileA_nonexisting_compressed(void)
Definition: lzexpand_main.c:209
buf
static char * buf
Definition: lzexpand_main.c:69
test_LZOpenFileA_existing_compressed
static void test_LZOpenFileA_existing_compressed(void)
Definition: lzexpand_main.c:118
_terminatedW_
static WCHAR _terminatedW_[]
Definition: lzexpand_main.c:49
test_LZOpenFileW_nonexisting_compressed
static void test_LZOpenFileW_nonexisting_compressed(void)
Definition: lzexpand_main.c:609
dotlessW_
static WCHAR dotlessW_[]
Definition: lzexpand_main.c:39
compressed_file_size
static const DWORD compressed_file_size
Definition: lzexpand_main.c:64
extless
static char extless[]
Definition: lzexpand_main.c:41
delete_fileW
static void delete_fileW(WCHAR *fnameW)
Definition: lzexpand_main.c:511
test_LZCopy
static void test_LZCopy(void)
Definition: lzexpand_main.c:453
test_LZOpenFileW_existing_compressed
static void test_LZOpenFileW_existing_compressed(void)
Definition: lzexpand_main.c:524
uncompressed_data
static const char uncompressed_data[]
Definition: lzexpand_main.c:66
test_LZRead
static void test_LZRead(void)
Definition: lzexpand_main.c:415
filenameW_
static WCHAR filenameW_[]
Definition: lzexpand_main.c:34
extlessW
static WCHAR extlessW[]
Definition: lzexpand_main.c:43
_terminatedW
static WCHAR _terminatedW[]
Definition: lzexpand_main.c:48
compressed_file
static const unsigned char compressed_file[]
Definition: lzexpand_main.c:59
test_LZOpenFileA
static void test_LZOpenFileA(void)
Definition: lzexpand_main.c:298
filename2
static char filename2[]
Definition: lzexpand_main.c:51
dotless_
static char dotless_[]
Definition: lzexpand_main.c:37
full_file_path_name_in_a_CWD
static void full_file_path_name_in_a_CWD(const char *src, char *dst, BOOL expect_short)
Definition: lzexpand_main.c:71
dotless
static char dotless[]
Definition: lzexpand_main.c:36
extless_
static char extless_[]
Definition: lzexpand_main.c:42
dotlessW
static WCHAR dotlessW[]
Definition: lzexpand_main.c:38
filename_
static char filename_[]
Definition: lzexpand_main.c:32
create_fileW
static void create_fileW(WCHAR *fnameW)
Definition: lzexpand_main.c:498
test_LZOpenFileW
static void test_LZOpenFileW(void)
Definition: lzexpand_main.c:698
uncompressed_data_size
static const DWORD uncompressed_data_size
Definition: lzexpand_main.c:67
_terminated_
static char _terminated_[]
Definition: lzexpand_main.c:47
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
CREATE_NEW
#define CREATE_NEW
Definition: disk.h:69
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
expected
BOOL expected
Definition: store.c:2063
create_file
#define create_file(name, size)
Definition: asmcache.c:813
todo_wine
#define todo_wine
Definition: custom.c:89
dest
static char * dest
Definition: rtl.c:135
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
delete_file
#define delete_file(f)
Definition: reg_test.h:97
test
#define test
Definition: rosglue.h:37
cfile
static FILE * cfile
Definition: ruserpass.c:25
win_skip
#define win_skip
Definition: test.h:164
memset
#define memset(x, y, z)
Definition: compat.h:39
_OFSTRUCT
Definition: winbase.h:1329
_OFSTRUCT::szPathName
CHAR szPathName[OFS_MAXPATHNAME]
Definition: winbase.h:1335
file
Definition: fci.c:127
INT
int32_t INT
Definition: typedefs.h:58
INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
retval
int retval
Definition: wcstombs.cpp:91
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
OF_EXIST
#define OF_EXIST
Definition: winbase.h:135
OF_READWRITE
#define OF_READWRITE
Definition: winbase.h:125
OFS_MAXPATHNAME
#define OFS_MAXPATHNAME
Definition: winbase.h:160
OF_READ
#define OF_READ
Definition: winbase.h:124
OF_CREATE
#define OF_CREATE
Definition: winbase.h:133
OF_DELETE
#define OF_DELETE
Definition: winbase.h:134
OF_WRITE
#define OF_WRITE
Definition: winbase.h:126
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180