git.oblomov.eu Git - wine/blob - 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 }