winmm: Fix a failing mixer test on 98 and ME.
[wine] / dlls / setupapi / tests / misc.c
1 /*
2  * Miscellaneous tests
3  *
4  * Copyright 2007 James Hawkins
5  * Copyright 2007 Hans Leidekker
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winnls.h"
29 #include "winuser.h"
30 #include "winreg.h"
31 #include "setupapi.h"
32
33 #include "wine/test.h"
34
35 static CHAR CURR_DIR[MAX_PATH];
36
37 /* test:
38  *  - fails if not administrator
39  *  - what if it's not a .inf file?
40  *  - copied to %windir%/Inf
41  *  - SourceInfFileName should be a full path
42  *  - SourceInfFileName should be <= MAX_PATH
43  *  - copy styles
44  */
45
46 static BOOL (WINAPI *pSetupGetFileCompressionInfoExA)(PCSTR, PSTR, DWORD, PDWORD, PDWORD, PDWORD, PUINT);
47 static BOOL (WINAPI *pSetupCopyOEMInfA)(PCSTR, PCSTR, DWORD, DWORD, PSTR, DWORD, PDWORD, PSTR *);
48 static BOOL (WINAPI *pSetupQueryInfOriginalFileInformationA)(PSP_INF_INFORMATION, UINT, PSP_ALTPLATFORM_INFO, PSP_ORIGINAL_FILE_INFO_A);
49
50 static void append_str(char **str, const char *data)
51 {
52     sprintf(*str, data);
53     *str += strlen(*str);
54 }
55
56 static void create_inf_file(LPCSTR filename)
57 {
58     char data[1024];
59     char *ptr = data;
60     DWORD dwNumberOfBytesWritten;
61     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
62                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
63
64     append_str(&ptr, "[Version]\n");
65     append_str(&ptr, "Signature=\"$Chicago$\"\n");
66     append_str(&ptr, "AdvancedINF=2.5\n");
67     append_str(&ptr, "[DefaultInstall]\n");
68     append_str(&ptr, "RegisterOCXs=RegisterOCXsSection\n");
69     append_str(&ptr, "[RegisterOCXsSection]\n");
70     append_str(&ptr, "%%11%%\\ole32.dll\n");
71
72     WriteFile(hf, data, ptr - data, &dwNumberOfBytesWritten, NULL);
73     CloseHandle(hf);
74 }
75
76 static void get_temp_filename(LPSTR path)
77 {
78     CHAR temp[MAX_PATH];
79     LPSTR ptr;
80
81     GetTempFileName(CURR_DIR, "set", 0, temp);
82     ptr = strrchr(temp, '\\');
83
84     lstrcpy(path, ptr + 1);
85 }
86
87 static BOOL file_exists(LPSTR path)
88 {
89     return GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES;
90 }
91
92 static BOOL check_format(LPSTR path, LPSTR inf)
93 {
94     CHAR check[MAX_PATH];
95     BOOL res;
96
97     static const CHAR format[] = "\\INF\\oem";
98
99     GetWindowsDirectory(check, MAX_PATH);
100     lstrcat(check, format);
101     res = CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, check, -1, path, lstrlen(check)) == CSTR_EQUAL &&
102           path[lstrlen(check)] != '\\';
103
104     return (!inf) ? res : res && (inf == path + lstrlen(check) - 3);
105 }
106
107 static void test_original_file_name(LPCSTR original, LPCSTR dest)
108 {
109     HINF hinf;
110     PSP_INF_INFORMATION pspii;
111     SP_ORIGINAL_FILE_INFO spofi;
112     BOOL res;
113     DWORD size;
114
115     if (!pSetupQueryInfOriginalFileInformationA)
116     {
117         skip("SetupQueryInfOriginalFileInformationA is not available\n");
118         return;
119     }
120
121     hinf = SetupOpenInfFileA(dest, NULL, INF_STYLE_WIN4, NULL);
122     ok(hinf != NULL, "SetupOpenInfFileA failed with error %d\n", GetLastError());
123
124     res = SetupGetInfInformation(hinf, INFINFO_INF_SPEC_IS_HINF, NULL, 0, &size);
125     ok(res, "SetupGetInfInformation failed with error %d\n", GetLastError());
126
127     pspii = HeapAlloc(GetProcessHeap(), 0, size);
128
129     res = SetupGetInfInformation(hinf, INFINFO_INF_SPEC_IS_HINF, pspii, size, NULL);
130     ok(res, "SetupGetInfInformation failed with error %d\n", GetLastError());
131
132     spofi.cbSize = 0;
133     res = pSetupQueryInfOriginalFileInformationA(pspii, 0, NULL, &spofi);
134     ok(!res && GetLastError() == ERROR_INVALID_USER_BUFFER,
135         "SetupQueryInfOriginalFileInformationA should have failed with ERROR_INVALID_USER_BUFFER instead of %d\n", GetLastError());
136
137     spofi.cbSize = sizeof(spofi);
138     res = pSetupQueryInfOriginalFileInformationA(pspii, 0, NULL, &spofi);
139     ok(res, "SetupQueryInfOriginalFileInformationA failed with error %d\n", GetLastError());
140     ok(!spofi.OriginalCatalogName[0], "spofi.OriginalCatalogName should have been \"\" instead of \"%s\"\n", spofi.OriginalCatalogName);
141     todo_wine
142     ok(!strcmp(original, spofi.OriginalInfName), "spofi.OriginalInfName of %s didn't match real original name %s\n", spofi.OriginalInfName, original);
143
144     HeapFree(GetProcessHeap(), 0, pspii);
145
146     SetupCloseInfFile(hinf);
147 }
148
149 static void test_SetupCopyOEMInf(void)
150 {
151     CHAR toolong[MAX_PATH * 2];
152     CHAR path[MAX_PATH], dest[MAX_PATH];
153     CHAR tmpfile[MAX_PATH], dest_save[MAX_PATH];
154     LPSTR inf;
155     DWORD size;
156     BOOL res;
157
158     /* try NULL SourceInfFileName */
159     SetLastError(0xdeadbeef);
160     res = pSetupCopyOEMInfA(NULL, NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
161     ok(res == FALSE, "Expected FALSE, got %d\n", res);
162     ok(GetLastError() == ERROR_INVALID_PARAMETER,
163        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
164
165     /* try empty SourceInfFileName */
166     SetLastError(0xdeadbeef);
167     res = pSetupCopyOEMInfA("", NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
168     ok(res == FALSE, "Expected FALSE, got %d\n", res);
169     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
170        GetLastError() == ERROR_BAD_PATHNAME, /* Win98 */
171        "Expected ERROR_FILE_NOT_FOUND or ERROR_BAD_PATHNAME, got %d\n", GetLastError());
172
173     /* try a relative nonexistent SourceInfFileName */
174     SetLastError(0xdeadbeef);
175     res = pSetupCopyOEMInfA("nonexistent", NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
176     ok(res == FALSE, "Expected FALSE, got %d\n", res);
177     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
178        "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
179
180     /* try an absolute nonexistent SourceInfFileName */
181     lstrcpy(path, CURR_DIR);
182     lstrcat(path, "\\nonexistent");
183     SetLastError(0xdeadbeef);
184     res = pSetupCopyOEMInfA(path, NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
185     ok(res == FALSE, "Expected FALSE, got %d\n", res);
186     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
187        "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
188
189     /* try a long SourceInfFileName */
190     memset(toolong, 'a', MAX_PATH * 2);
191     toolong[MAX_PATH * 2 - 1] = '\0';
192     SetLastError(0xdeadbeef);
193     res = pSetupCopyOEMInfA(toolong, NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
194     ok(res == FALSE, "Expected FALSE, got %d\n", res);
195     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
196        GetLastError() == ERROR_FILENAME_EXCED_RANGE, /* Win98 */
197        "Expected ERROR_FILE_NOT_FOUND or ERROR_FILENAME_EXCED_RANGE, got %d\n", GetLastError());
198
199     get_temp_filename(tmpfile);
200     create_inf_file(tmpfile);
201
202     /* try a relative SourceInfFileName */
203     SetLastError(0xdeadbeef);
204     res = pSetupCopyOEMInfA(tmpfile, NULL, 0, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
205     ok(res == FALSE, "Expected FALSE, got %d\n", res);
206     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
207        "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
208     ok(file_exists(tmpfile), "Expected tmpfile to exist\n");
209
210     /* try SP_COPY_REPLACEONLY, dest does not exist */
211     SetLastError(0xdeadbeef);
212     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, SP_COPY_REPLACEONLY, NULL, 0, NULL, NULL);
213     ok(res == FALSE, "Expected FALSE, got %d\n", res);
214     ok(GetLastError() == ERROR_FILE_NOT_FOUND,
215        "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
216     ok(file_exists(tmpfile), "Expected source inf to exist\n");
217
218     /* try an absolute SourceInfFileName, without DestinationInfFileName */
219     lstrcpy(path, CURR_DIR);
220     lstrcat(path, "\\");
221     lstrcat(path, tmpfile);
222     SetLastError(0xdeadbeef);
223     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, 0, NULL, 0, NULL, NULL);
224     ok(res == TRUE, "Expected TRUE, got %d\n", res);
225     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
226     ok(file_exists(path), "Expected source inf to exist\n");
227
228     /* try SP_COPY_REPLACEONLY, dest exists */
229     SetLastError(0xdeadbeef);
230     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, SP_COPY_REPLACEONLY, NULL, 0, NULL, NULL);
231     ok(res == TRUE, "Expected TRUE, got %d\n", res);
232     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
233     ok(file_exists(path), "Expected source inf to exist\n");
234
235     /* try SP_COPY_NOOVERWRITE */
236     SetLastError(0xdeadbeef);
237     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, SP_COPY_NOOVERWRITE, NULL, 0, NULL, NULL);
238     ok(res == FALSE, "Expected FALSE, got %d\n", res);
239     ok(GetLastError() == ERROR_FILE_EXISTS,
240        "Expected ERROR_FILE_EXISTS, got %d\n", GetLastError());
241
242     /* get the DestinationInfFileName */
243     SetLastError(0xdeadbeef);
244     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, 0, dest, MAX_PATH, NULL, NULL);
245     ok(res == TRUE, "Expected TRUE, got %d\n", res);
246     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
247     ok(lstrlen(dest) != 0, "Expected a non-zero length string\n");
248     ok(file_exists(dest), "Expected destination inf to exist\n");
249     ok(check_format(dest, NULL), "Expected %%windir%%\\inf\\OEMx.inf, got %s\n", dest);
250     ok(file_exists(path), "Expected source inf to exist\n");
251
252     lstrcpy(dest_save, dest);
253     DeleteFile(dest_save);
254
255     /* get the DestinationInfFileName, DestinationInfFileNameSize is too small
256      *   - inf is still copied
257      */
258     lstrcpy(dest, "aaa");
259     size = 0;
260     SetLastError(0xdeadbeef);
261     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, 0, dest, 5, &size, NULL);
262     ok(res == FALSE, "Expected FALSE, got %d\n", res);
263     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
264        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
265     ok(file_exists(path), "Expected source inf to exist\n");
266     ok(file_exists(dest_save), "Expected dest inf to exist\n");
267     ok(!lstrcmp(dest, "aaa"), "Expected dest to be unchanged\n");
268     ok(size == lstrlen(dest_save) + 1, "Expected size to be lstrlen(dest_save) + 1\n");
269
270     /* get the DestinationInfFileName and DestinationInfFileNameSize */
271     SetLastError(0xdeadbeef);
272     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, 0, dest, MAX_PATH, &size, NULL);
273     ok(res == TRUE, "Expected TRUE, got %d\n", res);
274     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
275     ok(lstrlen(dest) + 1 == size, "Expected sizes to match, got (%d, %d)\n", lstrlen(dest), size);
276     ok(file_exists(dest), "Expected destination inf to exist\n");
277     ok(check_format(dest, NULL), "Expected %%windir%%\\inf\\OEMx.inf, got %s\n", dest);
278     ok(file_exists(path), "Expected source inf to exist\n");
279     ok(size == lstrlen(dest_save) + 1, "Expected size to be lstrlen(dest_save) + 1\n");
280
281     test_original_file_name(strrchr(path, '\\') + 1, dest);
282
283     /* get the DestinationInfFileName, DestinationInfFileNameSize, and DestinationInfFileNameComponent */
284     SetLastError(0xdeadbeef);
285     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, 0, dest, MAX_PATH, &size, &inf);
286     ok(res == TRUE, "Expected TRUE, got %d\n", res);
287     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
288     ok(lstrlen(dest) + 1 == size, "Expected sizes to match, got (%d, %d)\n", lstrlen(dest), size);
289     ok(file_exists(dest), "Expected destination inf to exist\n");
290     ok(check_format(dest, inf), "Expected %%windir%%\\inf\\OEMx.inf, got %s\n", dest);
291     ok(file_exists(path), "Expected source inf to exist\n");
292     ok(size == lstrlen(dest_save) + 1, "Expected size to be lstrlen(dest_save) + 1\n");
293
294     /* try SP_COPY_DELETESOURCE */
295     SetLastError(0xdeadbeef);
296     res = pSetupCopyOEMInfA(path, NULL, SPOST_NONE, SP_COPY_DELETESOURCE, NULL, 0, NULL, NULL);
297     ok(res == TRUE, "Expected TRUE, got %d\n", res);
298     ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
299     ok(!file_exists(path), "Expected source inf to not exist\n");
300 }
301
302 static void create_source_file(LPSTR filename, const BYTE *data, DWORD size)
303 {
304     HANDLE handle;
305     DWORD written;
306
307     handle = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
308     WriteFile(handle, data, size, &written, NULL);
309     CloseHandle(handle);
310 }
311
312 static BOOL compare_file_data(LPSTR file, const BYTE *data, DWORD size)
313 {
314     DWORD read;
315     HANDLE handle;
316     BOOL ret = FALSE;
317     LPBYTE buffer;
318
319     handle = CreateFileA(file, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
320     buffer = HeapAlloc(GetProcessHeap(), 0, size);
321     if (buffer)
322     {
323         ReadFile(handle, buffer, size, &read, NULL);
324         if (read == size && !memcmp(data, buffer, size)) ret = TRUE;
325         HeapFree(GetProcessHeap(), 0, buffer);
326     }
327     CloseHandle(handle);
328     return ret;
329 }
330
331 static const BYTE uncompressed[] = {
332     'u','n','c','o','m','p','r','e','s','s','e','d','\r','\n'
333 };
334 static const BYTE comp_lzx[] = {
335     0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33, 0x41, 0x00, 0x0e, 0x00, 0x00, 0x00, 0xff, 0x00,
336     0x00, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x3f, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64
337 };
338 static const BYTE comp_zip[] = {
339     0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0xae, 0x81, 0x36, 0x75, 0x11,
340     0x2c, 0x1b, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x15, 0x00, 0x77, 0x69,
341     0x6e, 0x65, 0x55, 0x54, 0x09, 0x00, 0x03, 0xd6, 0x0d, 0x10, 0x46, 0xfd, 0x0d, 0x10, 0x46, 0x55,
342     0x78, 0x04, 0x00, 0xe8, 0x03, 0xe8, 0x03, 0x00, 0x00, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72,
343     0x65, 0x73, 0x73, 0x65, 0x64, 0x50, 0x4b, 0x01, 0x02, 0x17, 0x03, 0x0a, 0x00, 0x00, 0x00, 0x00,
344     0x00, 0xbd, 0xae, 0x81, 0x36, 0x75, 0x11, 0x2c, 0x1b, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
345     0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x81, 0x00,
346     0x00, 0x00, 0x00, 0x77, 0x69, 0x6e, 0x65, 0x55, 0x54, 0x05, 0x00, 0x03, 0xd6, 0x0d, 0x10, 0x46,
347     0x55, 0x78, 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
348     0x3f, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00
349 };
350 static const BYTE comp_cab_lzx[] = {
351     0x4d, 0x53, 0x43, 0x46, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352     0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
353     0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x0f, 0x0e, 0x00, 0x00, 0x00,
354     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x36, 0x86, 0x72, 0x20, 0x00, 0x77, 0x69, 0x6e, 0x65,
355     0x00, 0x19, 0xd0, 0x1a, 0xe3, 0x22, 0x00, 0x0e, 0x00, 0x5b, 0x80, 0x80, 0x8d, 0x00, 0x30, 0xe0,
356     0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75, 0x6e, 0x63,
357     0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x0d, 0x0a
358 };
359 static const BYTE comp_cab_zip[] =  {
360     0x4d, 0x53, 0x43, 0x46, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
361     0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
362     0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0e, 0x00, 0x00, 0x00,
363     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x36, 0x2f, 0xa5, 0x20, 0x00, 0x77, 0x69, 0x6e, 0x65,
364     0x00, 0x7c, 0x80, 0x26, 0x2b, 0x12, 0x00, 0x0e, 0x00, 0x43, 0x4b, 0x2b, 0xcd, 0x4b, 0xce, 0xcf,
365     0x2d, 0x28, 0x4a, 0x2d, 0x2e, 0x4e, 0x4d, 0xe1, 0xe5, 0x02, 0x00
366 };
367
368 static void test_SetupGetFileCompressionInfo(void)
369 {
370     DWORD ret, source_size, target_size;
371     char source[MAX_PATH], temp[MAX_PATH], *name;
372     UINT type;
373
374     GetTempPathA(sizeof(temp), temp);
375     GetTempFileNameA(temp, "fci", 0, source);
376
377     create_source_file(source, uncompressed, sizeof(uncompressed));
378
379     ret = SetupGetFileCompressionInfoA(NULL, NULL, NULL, NULL, NULL);
380     ok(ret == ERROR_INVALID_PARAMETER, "SetupGetFileCompressionInfo failed unexpectedly\n");
381
382     ret = SetupGetFileCompressionInfoA(source, NULL, NULL, NULL, NULL);
383     ok(ret == ERROR_INVALID_PARAMETER, "SetupGetFileCompressionInfo failed unexpectedly\n");
384
385     ret = SetupGetFileCompressionInfoA(source, &name, NULL, NULL, NULL);
386     ok(ret == ERROR_INVALID_PARAMETER, "SetupGetFileCompressionInfo failed unexpectedly\n");
387
388     ret = SetupGetFileCompressionInfoA(source, &name, &source_size, NULL, NULL);
389     ok(ret == ERROR_INVALID_PARAMETER, "SetupGetFileCompressionInfo failed unexpectedly\n");
390
391     ret = SetupGetFileCompressionInfoA(source, &name, &source_size, &target_size, NULL);
392     ok(ret == ERROR_INVALID_PARAMETER, "SetupGetFileCompressionInfo failed unexpectedly\n");
393
394     name = NULL;
395     source_size = target_size = 0;
396     type = 5;
397
398     ret = SetupGetFileCompressionInfoA(source, &name, &source_size, &target_size, &type);
399     ok(!ret, "SetupGetFileCompressionInfo failed unexpectedly\n");
400     ok(name && !lstrcmpA(name, source), "got %s, expected %s\n", name, source);
401     ok(source_size == sizeof(uncompressed), "got %d\n", source_size);
402     ok(target_size == sizeof(uncompressed), "got %d\n", target_size);
403     ok(type == FILE_COMPRESSION_NONE, "got %d, expected FILE_COMPRESSION_NONE\n", type);
404
405     MyFree(name);
406     DeleteFileA(source);
407 }
408
409 static void test_SetupGetFileCompressionInfoEx(void)
410 {
411     BOOL ret;
412     DWORD required_len, source_size, target_size;
413     char source[MAX_PATH], temp[MAX_PATH], name[MAX_PATH];
414     UINT type;
415
416     GetTempPathA(sizeof(temp), temp);
417     GetTempFileNameA(temp, "doc", 0, source);
418
419     ret = pSetupGetFileCompressionInfoExA(NULL, NULL, 0, NULL, NULL, NULL, NULL);
420     ok(!ret, "SetupGetFileCompressionInfoEx succeeded unexpectedly\n");
421
422     ret = pSetupGetFileCompressionInfoExA(source, NULL, 0, NULL, NULL, NULL, NULL);
423     ok(!ret, "SetupGetFileCompressionInfoEx succeeded unexpectedly\n");
424
425     ret = pSetupGetFileCompressionInfoExA(source, NULL, 0, &required_len, NULL, NULL, NULL);
426     ok(!ret, "SetupGetFileCompressionInfoEx succeeded unexpectedly\n");
427     ok(required_len == lstrlenA(source) + 1, "got %d, expected %d\n", required_len, lstrlenA(source) + 1);
428
429     create_source_file(source, comp_lzx, sizeof(comp_lzx));
430
431     ret = pSetupGetFileCompressionInfoExA(source, name, sizeof(name), &required_len, &source_size, &target_size, &type);
432     ok(ret, "SetupGetFileCompressionInfoEx failed unexpectedly: %d\n", ret);
433     ok(!lstrcmpA(name, source), "got %s, expected %s\n", name, source);
434     ok(required_len == lstrlenA(source) + 1, "got %d, expected %d\n", required_len, lstrlenA(source) + 1);
435     ok(source_size == sizeof(comp_lzx), "got %d\n", source_size);
436     ok(target_size == sizeof(uncompressed), "got %d\n", target_size);
437     ok(type == FILE_COMPRESSION_WINLZA, "got %d, expected FILE_COMPRESSION_WINLZA\n", type);
438     DeleteFileA(source);
439
440     create_source_file(source, comp_zip, sizeof(comp_zip));
441
442     ret = pSetupGetFileCompressionInfoExA(source, name, sizeof(name), &required_len, &source_size, &target_size, &type);
443     ok(ret, "SetupGetFileCompressionInfoEx failed unexpectedly: %d\n", ret);
444     ok(!lstrcmpA(name, source), "got %s, expected %s\n", name, source);
445     ok(required_len == lstrlenA(source) + 1, "got %d, expected %d\n", required_len, lstrlenA(source) + 1);
446     ok(source_size == sizeof(comp_zip), "got %d\n", source_size);
447     ok(target_size == sizeof(comp_zip), "got %d\n", target_size);
448     ok(type == FILE_COMPRESSION_NONE, "got %d, expected FILE_COMPRESSION_NONE\n", type);
449     DeleteFileA(source);
450
451     create_source_file(source, comp_cab_lzx, sizeof(comp_cab_lzx));
452
453     ret = pSetupGetFileCompressionInfoExA(source, name, sizeof(name), &required_len, &source_size, &target_size, &type);
454     ok(ret, "SetupGetFileCompressionInfoEx failed unexpectedly: %d\n", ret);
455     ok(!lstrcmpA(name, source), "got %s, expected %s\n", name, source);
456     ok(required_len == lstrlenA(source) + 1, "got %d, expected %d\n", required_len, lstrlenA(source) + 1);
457     ok(source_size == sizeof(comp_cab_lzx), "got %d\n", source_size);
458     ok(target_size == sizeof(uncompressed), "got %d\n", target_size);
459     ok(type == FILE_COMPRESSION_MSZIP, "got %d, expected FILE_COMPRESSION_MSZIP\n", type);
460     DeleteFileA(source);
461
462     create_source_file(source, comp_cab_zip, sizeof(comp_cab_zip));
463
464     ret = pSetupGetFileCompressionInfoExA(source, name, sizeof(name), &required_len, &source_size, &target_size, &type);
465     ok(ret, "SetupGetFileCompressionInfoEx failed unexpectedly: %d\n", ret);
466     ok(!lstrcmpA(name, source), "got %s, expected %s\n", name, source);
467     ok(required_len == lstrlenA(source) + 1, "got %d, expected %d\n", required_len, lstrlenA(source) + 1);
468     ok(source_size == sizeof(comp_cab_zip), "got %d\n", source_size);
469     ok(target_size == sizeof(uncompressed), "got %d\n", target_size);
470     ok(type == FILE_COMPRESSION_MSZIP, "got %d, expected FILE_COMPRESSION_MSZIP\n", type);
471     DeleteFileA(source);
472 }
473
474 static void test_SetupDecompressOrCopyFile(void)
475 {
476     DWORD ret;
477     char source[MAX_PATH], target[MAX_PATH], temp[MAX_PATH], *p;
478     UINT type;
479
480     GetTempPathA(sizeof(temp), temp);
481     GetTempFileNameA(temp, "doc", 0, source);
482     GetTempFileNameA(temp, "doc", 0, target);
483
484     /* parameter tests */
485
486     create_source_file(source, uncompressed, sizeof(uncompressed));
487
488     ret = SetupDecompressOrCopyFileA(NULL, NULL, NULL);
489     ok(ret == ERROR_INVALID_PARAMETER, "SetupDecompressOrCopyFile failed unexpectedly\n");
490
491     type = FILE_COMPRESSION_NONE;
492     ret = SetupDecompressOrCopyFileA(NULL, target, &type);
493     ok(ret == ERROR_INVALID_PARAMETER, "SetupDecompressOrCopyFile failed unexpectedly\n");
494
495     ret = SetupDecompressOrCopyFileA(source, NULL, &type);
496     ok(ret == ERROR_INVALID_PARAMETER, "SetupDecompressOrCopyFile failed unexpectedly\n");
497
498     type = 5; /* try an invalid compression type */
499     ret = SetupDecompressOrCopyFileA(source, target, &type);
500     ok(ret == ERROR_INVALID_PARAMETER, "SetupDecompressOrCopyFile failed unexpectedly\n");
501
502     DeleteFileA(target);
503
504     /* no compression tests */
505
506     ret = SetupDecompressOrCopyFileA(source, target, NULL);
507     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
508     ok(compare_file_data(target, uncompressed, sizeof(uncompressed)), "incorrect target file\n");
509
510     /* try overwriting existing file */
511     ret = SetupDecompressOrCopyFileA(source, target, NULL);
512     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
513     DeleteFileA(target);
514
515     type = FILE_COMPRESSION_NONE;
516     ret = SetupDecompressOrCopyFileA(source, target, &type);
517     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
518     ok(compare_file_data(target, uncompressed, sizeof(uncompressed)), "incorrect target file\n");
519     DeleteFileA(target);
520
521     type = FILE_COMPRESSION_WINLZA;
522     ret = SetupDecompressOrCopyFileA(source, target, &type);
523     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
524     ok(compare_file_data(target, uncompressed, sizeof(uncompressed)), "incorrect target file\n");
525     DeleteFileA(target);
526
527     /* lz compression tests */
528
529     create_source_file(source, comp_lzx, sizeof(comp_lzx));
530
531     ret = SetupDecompressOrCopyFileA(source, target, NULL);
532     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
533     DeleteFileA(target);
534
535     /* zip compression tests */
536
537     create_source_file(source, comp_zip, sizeof(comp_zip));
538
539     ret = SetupDecompressOrCopyFileA(source, target, NULL);
540     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
541     ok(compare_file_data(target, comp_zip, sizeof(comp_zip)), "incorrect target file\n");
542     DeleteFileA(target);
543
544     /* cabinet compression tests */
545
546     create_source_file(source, comp_cab_zip, sizeof(comp_cab_zip));
547
548     p = strrchr(target, '\\');
549     lstrcpyA(p + 1, "wine");
550
551     ret = SetupDecompressOrCopyFileA(source, target, NULL);
552     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
553     ok(compare_file_data(target, uncompressed, sizeof(uncompressed)), "incorrect target file\n");
554
555     /* try overwriting existing file */
556     ret = SetupDecompressOrCopyFileA(source, target, NULL);
557     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
558
559     /* try zip compression */
560     type = FILE_COMPRESSION_MSZIP;
561     ret = SetupDecompressOrCopyFileA(source, target, &type);
562     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
563     ok(compare_file_data(target, uncompressed, sizeof(uncompressed)), "incorrect target file\n");
564
565     /* try no compression */
566     type = FILE_COMPRESSION_NONE;
567     ret = SetupDecompressOrCopyFileA(source, target, &type);
568     ok(!ret, "SetupDecompressOrCopyFile failed unexpectedly: %d\n", ret);
569     ok(compare_file_data(target, comp_cab_zip, sizeof(comp_cab_zip)), "incorrect target file\n");
570
571     DeleteFileA(target);
572     DeleteFileA(source);
573 }
574
575 START_TEST(misc)
576 {
577     HMODULE hsetupapi = GetModuleHandle("setupapi.dll");
578
579     pSetupGetFileCompressionInfoExA = (void*)GetProcAddress(hsetupapi, "SetupGetFileCompressionInfoExA");
580     pSetupCopyOEMInfA = (void*)GetProcAddress(hsetupapi, "SetupCopyOEMInfA");
581     pSetupQueryInfOriginalFileInformationA = (void*)GetProcAddress(hsetupapi, "SetupQueryInfOriginalFileInformationA");
582
583     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
584
585     if (pSetupCopyOEMInfA)
586         test_SetupCopyOEMInf();
587     else
588         skip("SetupCopyOEMInfA is not available\n");
589
590     test_SetupGetFileCompressionInfo();
591
592     if (pSetupGetFileCompressionInfoExA)
593         test_SetupGetFileCompressionInfoEx();
594     else
595         skip("SetupGetFileCompressionInfoExA is not available\n");
596
597     test_SetupDecompressOrCopyFile();
598 }