git.oblomov.eu Git - wine/blob - dlls/msi/tests/automation.c

   1 /*
   2  * Copyright (C) 2007 Mike McCormack for CodeWeavers
   3  * Copyright (C) 2007 Misha Koshelev
   4  *
   5  * A test program for Microsoft Installer OLE automation functionality.
   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 #define COBJMACROS
  23
  24 #include <stdio.h>
  25
  26 #include <initguid.h>
  27 #include <windows.h>
  28 #include <msiquery.h>
  29 #include <msidefs.h>
  30 #include <msi.h>
  31 #include <fci.h>
  32
  33 #include "wine/test.h"
  34
  35 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  36
  37 static const char *msifile = "winetest.msi";
  38 static const WCHAR szMsifile[] = {'w','i','n','e','t','e','s','t','.','m','s','i',0};
  39 static const WCHAR szMSITEST[] = { 'M','S','I','T','E','S','T',0 };
  40 static const WCHAR szProductCode[] = { '{','F','1','C','3','A','F','5','0','-','8','B','5','6','-','4','A','6','9','-','A','0','0','C','-','0','0','7','7','3','F','E','4','2','F','3','0','}',0 };
  41 static const WCHAR szUpgradeCode[] = { '{','C','E','0','6','7','E','8','D','-','2','E','1','A','-','4','3','6','7','-','B','7','3','4','-','4','E','B','2','B','D','A','D','6','5','6','5','}',0 };
  42 static const WCHAR szProductInfoException[] = { 'P','r','o','d','u','c','t','I','n','f','o',',','P','r','o','d','u','c','t',',','A','t','t','r','i','b','u','t','e',0 };
  43 static const WCHAR WINE_INSTALLPROPERTY_PACKAGENAMEW[] = {'P','a','c','k','a','g','e','N','a','m','e',0};
  44 static const WCHAR WINE_INSTALLPROPERTY_PRODUCTNAMEW[] = {'P','r','o','d','u','c','t','N','a','m','e',0};
  45 static FILETIME systemtime;
  46 static CHAR CURR_DIR[MAX_PATH];
  47 static EXCEPINFO excepinfo;
  48
  49 /*
  50  * OLE automation data
  51  **/
  52 static const WCHAR szProgId[] = { 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r','.','I','n','s','t','a','l','l','e','r',0 };
  53 static IDispatch *pInstaller;
  54
  55 /* msi database data */
  56
  57 static const CHAR component_dat[] = "Component\tComponentId\tDirectory_\tAttributes\tCondition\tKeyPath\n"
  58                                     "s72\tS38\ts72\ti2\tS255\tS72\n"
  59                                     "Component\tComponent\n"
  60                                     "Five\t{8CC92E9D-14B2-4CA4-B2AA-B11D02078087}\tNEWDIR\t2\t\tfive.txt\n"
  61                                     "Four\t{FD37B4EA-7209-45C0-8917-535F35A2F080}\tCABOUTDIR\t2\t\tfour.txt\n"
  62                                     "One\t{783B242E-E185-4A56-AF86-C09815EC053C}\tMSITESTDIR\t2\t\tone.txt\n"
  63                                     "Three\t{010B6ADD-B27D-4EDD-9B3D-34C4F7D61684}\tCHANGEDDIR\t2\t\tthree.txt\n"
  64                                     "Two\t{BF03D1A6-20DA-4A65-82F3-6CAC995915CE}\tFIRSTDIR\t2\t\ttwo.txt\n"
  65                                     "dangler\t{6091DF25-EF96-45F1-B8E9-A9B1420C7A3C}\tTARGETDIR\t4\t\tregdata\n"
  66                                     "component\t\tMSITESTDIR\t0\t1\tfile\n";
  67
  68 static const CHAR directory_dat[] = "Directory\tDirectory_Parent\tDefaultDir\n"
  69                                     "s72\tS72\tl255\n"
  70                                     "Directory\tDirectory\n"
  71                                     "CABOUTDIR\tMSITESTDIR\tcabout\n"
  72                                     "CHANGEDDIR\tMSITESTDIR\tchanged:second\n"
  73                                     "FIRSTDIR\tMSITESTDIR\tfirst\n"
  74                                     "MSITESTDIR\tProgramFilesFolder\tmsitest\n"
  75                                     "NEWDIR\tCABOUTDIR\tnew\n"
  76                                     "ProgramFilesFolder\tTARGETDIR\t.\n"
  77                                     "TARGETDIR\t\tSourceDir";
  78
  79 static const CHAR feature_dat[] = "Feature\tFeature_Parent\tTitle\tDescription\tDisplay\tLevel\tDirectory_\tAttributes\n"
  80                                   "s38\tS38\tL64\tL255\tI2\ti2\tS72\ti2\n"
  81                                   "Feature\tFeature\n"
  82                                   "Five\t\tFive\tThe Five Feature\t5\t3\tNEWDIR\t0\n"
  83                                   "Four\t\tFour\tThe Four Feature\t4\t3\tCABOUTDIR\t0\n"
  84                                   "One\t\tOne\tThe One Feature\t1\t3\tMSITESTDIR\t0\n"
  85                                   "Three\tOne\tThree\tThe Three Feature\t3\t3\tCHANGEDDIR\t0\n"
  86                                   "Two\tOne\tTwo\tThe Two Feature\t2\t3\tFIRSTDIR\t0\n"
  87                                   "feature\t\t\t\t2\t1\tTARGETDIR\t0\n";
  88
  89 static const CHAR feature_comp_dat[] = "Feature_\tComponent_\n"
  90                                        "s38\ts72\n"
  91                                        "FeatureComponents\tFeature_\tComponent_\n"
  92                                        "Five\tFive\n"
  93                                        "Four\tFour\n"
  94                                        "One\tOne\n"
  95                                        "Three\tThree\n"
  96                                        "Two\tTwo\n"
  97                                        "feature\tcomponent\n";
  98
  99 static const CHAR file_dat[] = "File\tComponent_\tFileName\tFileSize\tVersion\tLanguage\tAttributes\tSequence\n"
 100                                "s72\ts72\tl255\ti4\tS72\tS20\tI2\ti2\n"
 101                                "File\tFile\n"
 102                                "five.txt\tFive\tfive.txt\t1000\t\t\t0\t5\n"
 103                                "four.txt\tFour\tfour.txt\t1000\t\t\t0\t4\n"
 104                                "one.txt\tOne\tone.txt\t1000\t\t\t0\t1\n"
 105                                "three.txt\tThree\tthree.txt\t1000\t\t\t0\t3\n"
 106                                "two.txt\tTwo\ttwo.txt\t1000\t\t\t0\t2\n"
 107                                "file\tcomponent\tfilename\t100\t\t\t8192\t1\n";
 108
 109 static const CHAR install_exec_seq_dat[] = "Action\tCondition\tSequence\n"
 110                                            "s72\tS255\tI2\n"
 111                                            "InstallExecuteSequence\tAction\n"
 112                                            "AllocateRegistrySpace\tNOT Installed\t1550\n"
 113                                            "CostFinalize\t\t1000\n"
 114                                            "CostInitialize\t\t800\n"
 115                                            "FileCost\t\t900\n"
 116                                            "InstallFiles\t\t4000\n"
 117                                            "RegisterProduct\t\t6100\n"
 118                                            "PublishProduct\t\t6400\n"
 119                                            "InstallFinalize\t\t6600\n"
 120                                            "InstallInitialize\t\t1500\n"
 121                                            "InstallValidate\t\t1400\n"
 122                                            "LaunchConditions\t\t100\n"
 123                                            "WriteRegistryValues\tSourceDir And SOURCEDIR\t5000";
 124
 125 static const CHAR media_dat[] = "DiskId\tLastSequence\tDiskPrompt\tCabinet\tVolumeLabel\tSource\n"
 126                                 "i2\ti4\tL64\tS255\tS32\tS72\n"
 127                                 "Media\tDiskId\n"
 128                                 "1\t5\t\t\tDISK1\t\n";
 129
 130 static const CHAR property_dat[] = "Property\tValue\n"
 131                                    "s72\tl0\n"
 132                                    "Property\tProperty\n"
 133                                    "DefaultUIFont\tDlgFont8\n"
 134                                    "HASUIRUN\t0\n"
 135                                    "INSTALLLEVEL\t3\n"
 136                                    "InstallMode\tTypical\n"
 137                                    "Manufacturer\tWine\n"
 138                                    "PIDTemplate\t12345<###-%%%%%%%>@@@@@\n"
 139                                    "ProductCode\t{F1C3AF50-8B56-4A69-A00C-00773FE42F30}\n"
 140                                    "ProductID\tnone\n"
 141                                    "ProductLanguage\t1033\n"
 142                                    "ProductName\tMSITEST\n"
 143                                    "ProductVersion\t1.1.1\n"
 144                                    "PROMPTROLLBACKCOST\tP\n"
 145                                    "Setup\tSetup\n"
 146                                    "UpgradeCode\t{CE067E8D-2E1A-4367-B734-4EB2BDAD6565}";
 147
 148 static const CHAR registry_dat[] = "Registry\tRoot\tKey\tName\tValue\tComponent_\n"
 149                                    "s72\ti2\tl255\tL255\tL0\ts72\n"
 150                                    "Registry\tRegistry\n"
 151                                    "Apples\t2\tSOFTWARE\\Wine\\msitest\tName\timaname\tOne\n"
 152                                    "Oranges\t2\tSOFTWARE\\Wine\\msitest\tnumber\t#314\tTwo\n"
 153                                    "regdata\t2\tSOFTWARE\\Wine\\msitest\tblah\tbad\tdangler\n"
 154                                    "OrderTest\t2\tSOFTWARE\\Wine\\msitest\tOrderTestName\tOrderTestValue\tcomponent";
 155
 156 typedef struct _msi_table
 157 {
 158     const CHAR *filename;
 159     const CHAR *data;
 160     int size;
 161 } msi_table;
 162
 163 #define ADD_TABLE(x) {#x".idt", x##_dat, sizeof(x##_dat)}
 164
 165 static const msi_table tables[] =
 166 {
 167     ADD_TABLE(component),
 168     ADD_TABLE(directory),
 169     ADD_TABLE(feature),
 170     ADD_TABLE(feature_comp),
 171     ADD_TABLE(file),
 172     ADD_TABLE(install_exec_seq),
 173     ADD_TABLE(media),
 174     ADD_TABLE(property),
 175     ADD_TABLE(registry)
 176 };
 177
 178 typedef struct _msi_summary_info
 179 {
 180     UINT property;
 181     UINT datatype;
 182     INT iValue;
 183     FILETIME *pftValue;
 184     const CHAR *szValue;
 185 } msi_summary_info;
 186
 187 #define ADD_INFO_I2(property, iValue) {property, VT_I2, iValue, NULL, NULL}
 188 #define ADD_INFO_I4(property, iValue) {property, VT_I4, iValue, NULL, NULL}
 189 #define ADD_INFO_LPSTR(property, szValue) {property, VT_LPSTR, 0, NULL, szValue}
 190 #define ADD_INFO_FILETIME(property, pftValue) {property, VT_FILETIME, 0, pftValue, NULL}
 191
 192 static const msi_summary_info summary_info[] =
 193 {
 194     ADD_INFO_LPSTR(PID_TEMPLATE, ";1033"),
 195     ADD_INFO_LPSTR(PID_REVNUMBER, "{004757CA-5092-49c2-AD20-28E1CE0DF5F2}"),
 196     ADD_INFO_I4(PID_PAGECOUNT, 100),
 197     ADD_INFO_I4(PID_WORDCOUNT, 0),
 198     ADD_INFO_FILETIME(PID_CREATE_DTM, &systemtime),
 199     ADD_INFO_FILETIME(PID_LASTPRINTED, &systemtime)
 200 };
 201
 202 /*
 203  * Database Helpers
 204  */
 205
 206 static void write_file(const CHAR *filename, const char *data, int data_size)
 207 {
 208     DWORD size;
 209
 210     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
 211                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 212
 213     WriteFile(hf, data, data_size, &size, NULL);
 214     CloseHandle(hf);
 215 }
 216
 217 static void write_msi_summary_info(MSIHANDLE db, const msi_summary_info *info, int num_info)
 218 {
 219     MSIHANDLE summary;
 220     UINT r;
 221     int j;
 222
 223     r = MsiGetSummaryInformationA(db, NULL, num_info, &summary);
 224     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 225
 226     /* import summary information into the stream */
 227     for (j = 0; j < num_info; j++)
 228     {
 229         const msi_summary_info *entry = &info[j];
 230
 231         r = MsiSummaryInfoSetPropertyA(summary, entry->property, entry->datatype,
 232                                        entry->iValue, entry->pftValue, entry->szValue);
 233         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 234     }
 235
 236     /* write the summary changes back to the stream */
 237     r = MsiSummaryInfoPersist(summary);
 238     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 239
 240     MsiCloseHandle(summary);
 241 }
 242
 243 static void create_database(const CHAR *name, const msi_table *tables, int num_tables,
 244                             const msi_summary_info *info, int num_info)
 245 {
 246     MSIHANDLE db;
 247     UINT r;
 248     int j;
 249
 250     r = MsiOpenDatabaseA(name, MSIDBOPEN_CREATE, &db);
 251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 252
 253     /* import the tables into the database */
 254     for (j = 0; j < num_tables; j++)
 255     {
 256         const msi_table *table = &tables[j];
 257
 258         write_file(table->filename, table->data, (table->size - 1) * sizeof(char));
 259
 260         r = MsiDatabaseImportA(db, CURR_DIR, table->filename);
 261         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 262
 263         DeleteFileA(table->filename);
 264     }
 265
 266     write_msi_summary_info(db, info, num_info);
 267
 268     r = MsiDatabaseCommit(db);
 269     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 270
 271     MsiCloseHandle(db);
 272 }
 273
 274 /*
 275  * Installation helpers
 276  */
 277
 278 static char PROG_FILES_DIR[MAX_PATH];
 279
 280 static BOOL get_program_files_dir(LPSTR buf)
 281 {
 282     HKEY hkey;
 283     DWORD type = REG_EXPAND_SZ, size;
 284
 285     if (RegOpenKey(HKEY_LOCAL_MACHINE,
 286                    "Software\\Microsoft\\Windows\\CurrentVersion", &hkey))
 287         return FALSE;
 288
 289     size = MAX_PATH;
 290     if (RegQueryValueEx(hkey, "ProgramFilesDir", 0, &type, (LPBYTE)buf, &size))
 291         return FALSE;
 292
 293     RegCloseKey(hkey);
 294     return TRUE;
 295 }
 296
 297 static void create_file(const CHAR *name, DWORD size)
 298 {
 299     HANDLE file;
 300     DWORD written, left;
 301
 302     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 303     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
 304     WriteFile(file, name, strlen(name), &written, NULL);
 305     WriteFile(file, "\n", strlen("\n"), &written, NULL);
 306
 307     left = size - lstrlen(name) - 1;
 308
 309     SetFilePointer(file, left, NULL, FILE_CURRENT);
 310     SetEndOfFile(file);
 311
 312     CloseHandle(file);
 313 }
 314
 315 static void create_test_files(void)
 316 {
 317     CreateDirectoryA("msitest", NULL);
 318     create_file("msitest\\one.txt", 100);
 319     CreateDirectoryA("msitest\\first", NULL);
 320     create_file("msitest\\first\\two.txt", 100);
 321     CreateDirectoryA("msitest\\second", NULL);
 322     create_file("msitest\\second\\three.txt", 100);
 323     CreateDirectoryA("msitest\\cabout",NULL);
 324     create_file("msitest\\cabout\\four.txt", 100);
 325     CreateDirectoryA("msitest\\cabout\\new",NULL);
 326     create_file("msitest\\cabout\\new\\five.txt", 100);
 327     create_file("msitest\\filename", 100);
 328 }
 329
 330 static BOOL delete_pf(const CHAR *rel_path, BOOL is_file)
 331 {
 332     CHAR path[MAX_PATH];
 333
 334     lstrcpyA(path, PROG_FILES_DIR);
 335     lstrcatA(path, "\\");
 336     lstrcatA(path, rel_path);
 337
 338     if (is_file)
 339         return DeleteFileA(path);
 340     else
 341         return RemoveDirectoryA(path);
 342 }
 343
 344 static void delete_test_files(void)
 345 {
 346     DeleteFileA(msifile);
 347     DeleteFileA("msitest\\cabout\\new\\five.txt");
 348     DeleteFileA("msitest\\cabout\\four.txt");
 349     DeleteFileA("msitest\\second\\three.txt");
 350     DeleteFileA("msitest\\first\\two.txt");
 351     DeleteFileA("msitest\\one.txt");
 352     DeleteFileA("msitest\\filename");
 353     RemoveDirectoryA("msitest\\cabout\\new");
 354     RemoveDirectoryA("msitest\\cabout");
 355     RemoveDirectoryA("msitest\\second");
 356     RemoveDirectoryA("msitest\\first");
 357     RemoveDirectoryA("msitest");
 358 }
 359
 360 /*
 361  * Automation helpers and tests
 362  */
 363
 364 /* ok-like statement which takes two unicode strings or one unicode and one ANSI string as arguments */
 365 static CHAR string1[MAX_PATH], string2[MAX_PATH];
 366
 367 #define ok_w2(format, szString1, szString2) \
 368 \
 369     if (lstrcmpW(szString1, szString2) != 0) \
 370     { \
 371         WideCharToMultiByte(CP_ACP, 0, szString1, -1, string1, MAX_PATH, NULL, NULL); \
 372         WideCharToMultiByte(CP_ACP, 0, szString2, -1, string2, MAX_PATH, NULL, NULL); \
 373         ok(0, format, string1, string2); \
 374     }
 375
 376 #define ok_w2n(format, szString1, szString2, len) \
 377 \
 378     if (memcmp(szString1, szString2, len * sizeof(WCHAR)) != 0) \
 379     { \
 380         WideCharToMultiByte(CP_ACP, 0, szString1, -1, string1, MAX_PATH, NULL, NULL); \
 381         WideCharToMultiByte(CP_ACP, 0, szString2, -1, string2, MAX_PATH, NULL, NULL); \
 382         ok(0, format, string1, string2); \
 383     }
 384
 385 #define ok_aw(format, aString, wString) \
 386 \
 387     WideCharToMultiByte(CP_ACP, 0, wString, -1, string1, MAX_PATH, NULL, NULL); \
 388     if (lstrcmpA(string1, aString) != 0) \
 389         ok(0, format, string1, aString); \
 390
 391 #define ok_awplus(format, extra, aString, wString)       \
 392 \
 393     WideCharToMultiByte(CP_ACP, 0, wString, -1, string1, MAX_PATH, NULL, NULL); \
 394     if (lstrcmpA(string1, aString) != 0) \
 395         ok(0, format, extra, string1, aString);  \
 396
 397 /* exception checker */
 398 static WCHAR szSource[] = {'M','s','i',' ','A','P','I',' ','E','r','r','o','r',0};
 399
 400 #define ok_exception(hr, szDescription)           \
 401     if (hr == DISP_E_EXCEPTION) \
 402     { \
 403         /* Compare wtype, source, and destination */                    \
 404         ok(excepinfo.wCode == 1000, "Exception info was %d, expected 1000\n", excepinfo.wCode); \
 405 \
 406         ok(excepinfo.bstrSource != NULL, "Exception source was NULL\n"); \
 407         if (excepinfo.bstrSource)                                       \
 408             ok_w2("Exception source was \"%s\" but expected to be \"%s\"\n", excepinfo.bstrSource, szSource); \
 409 \
 410         ok(excepinfo.bstrDescription != NULL, "Exception description was NULL\n"); \
 411         if (excepinfo.bstrDescription) \
 412             ok_w2("Exception description was \"%s\" but expected to be \"%s\"\n", excepinfo.bstrDescription, szDescription); \
 413 \
 414         SysFreeString(excepinfo.bstrSource); \
 415         SysFreeString(excepinfo.bstrDescription); \
 416         SysFreeString(excepinfo.bstrHelpFile); \
 417     }
 418
 419 static DISPID get_dispid( IDispatch *disp, const char *name )
 420 {
 421     LPOLESTR str;
 422     UINT len;
 423     DISPID id = -1;
 424     HRESULT r;
 425
 426     len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0 );
 427     str = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR) );
 428     if (str)
 429     {
 430         len = MultiByteToWideChar(CP_ACP, 0, name, -1, str, len );
 431         r = IDispatch_GetIDsOfNames( disp, &IID_NULL, &str, 1, 0, &id );
 432         HeapFree(GetProcessHeap(), 0, str);
 433         if (r != S_OK)
 434             return -1;
 435     }
 436
 437     return id;
 438 }
 439
 440 static void test_dispid(void)
 441 {
 442     DISPID dispid;
 443
 444     dispid = get_dispid(pInstaller, "CreateRecord");
 445     ok(dispid  == 1, "Expected 1, got %d\n", dispid);
 446     dispid = get_dispid(pInstaller, "OpenPackage");
 447     ok(dispid  == 2, "Expected 2, got %d\n", dispid);
 448     dispid = get_dispid(pInstaller, "OpenDatabase");
 449     ok(dispid == 4, "Expected 4, got %d\n", dispid);
 450     dispid = get_dispid( pInstaller, "UILevel" );
 451     ok(dispid == 6, "Expected 6, got %d\n", dispid);
 452     dispid = get_dispid(pInstaller, "InstallProduct");
 453     ok(dispid == 8, "Expected 8, got %d\n", dispid);
 454     dispid = get_dispid(pInstaller, "Version");
 455     ok(dispid == 9, "Expected 9, got %d\n", dispid);
 456     dispid = get_dispid(pInstaller, "RegistryValue");
 457     ok(dispid == 11, "Expected 11, got %d\n", dispid);
 458     todo_wine
 459     {
 460         dispid = get_dispid(pInstaller, "OpenProduct");
 461         ok(dispid  == 3, "Expected 3, got %d\n", dispid);
 462         dispid = get_dispid(pInstaller, "SummaryInformation");
 463         ok(dispid == 5, "Expected 5, got %d\n", dispid);
 464         dispid = get_dispid(pInstaller, "EnableLog");
 465         ok(dispid == 7, "Expected 7, got %d\n", dispid);
 466         dispid = get_dispid(pInstaller, "LastErrorRecord");
 467         ok(dispid == 10, "Expected 10, got %d\n", dispid);
 468         dispid = get_dispid(pInstaller, "Environment");
 469         ok(dispid == 12, "Expected 12, got %d\n", dispid);
 470         dispid = get_dispid(pInstaller, "FileAttributes");
 471         ok(dispid == 13, "Expected 13, got %d\n", dispid);
 472         dispid = get_dispid(pInstaller, "FileSize");
 473         ok(dispid == 15, "Expected 15, got %d\n", dispid);
 474         dispid = get_dispid(pInstaller, "FileVersion");
 475         ok(dispid == 16, "Expected 16, got %d\n", dispid);
 476     }
 477     dispid = get_dispid(pInstaller, "ProductState");
 478     ok(dispid == 17, "Expected 17, got %d\n", dispid);
 479     dispid = get_dispid(pInstaller, "ProductInfo");
 480     ok(dispid == 18, "Expected 18, got %d\n", dispid);
 481     todo_wine
 482     {
 483         dispid = get_dispid(pInstaller, "ConfigureProduct");
 484         ok(dispid == 19, "Expected 19, got %d\n", dispid);
 485         dispid = get_dispid(pInstaller, "ReinstallProduct");
 486         ok(dispid == 20 , "Expected 20, got %d\n", dispid);
 487         dispid = get_dispid(pInstaller, "CollectUserInfo");
 488         ok(dispid == 21, "Expected 21, got %d\n", dispid);
 489         dispid = get_dispid(pInstaller, "ApplyPatch");
 490         ok(dispid == 22, "Expected 22, got %d\n", dispid);
 491         dispid = get_dispid(pInstaller, "FeatureParent");
 492         ok(dispid == 23, "Expected 23, got %d\n", dispid);
 493         dispid = get_dispid(pInstaller, "FeatureState");
 494         ok(dispid == 24, "Expected 24, got %d\n", dispid);
 495         dispid = get_dispid(pInstaller, "UseFeature");
 496         ok(dispid == 25, "Expected 25, got %d\n", dispid);
 497         dispid = get_dispid(pInstaller, "FeatureUsageCount");
 498         ok(dispid == 26, "Expected 26, got %d\n", dispid);
 499         dispid = get_dispid(pInstaller, "FeatureUsageDate");
 500         ok(dispid == 27, "Expected 27, got %d\n", dispid);
 501         dispid = get_dispid(pInstaller, "ConfigureFeature");
 502         ok(dispid == 28, "Expected 28, got %d\n", dispid);
 503         dispid = get_dispid(pInstaller, "ReinstallFeature");
 504         ok(dispid == 29, "Expected 29, got %d\n", dispid);
 505         dispid = get_dispid(pInstaller, "ProvideComponent");
 506         ok(dispid == 30, "Expected 30, got %d\n", dispid);
 507         dispid = get_dispid(pInstaller, "ComponentPath");
 508         ok(dispid == 31, "Expected 31, got %d\n", dispid);
 509         dispid = get_dispid(pInstaller, "ProvideQualifiedComponent");
 510         ok(dispid == 32, "Expected 32, got %d\n", dispid);
 511         dispid = get_dispid(pInstaller, "QualifierDescription");
 512         ok(dispid == 33, "Expected 33, got %d\n", dispid);
 513         dispid = get_dispid(pInstaller, "ComponentQualifiers");
 514         ok(dispid == 34, "Expected 34, got %d\n", dispid);
 515     }
 516     dispid = get_dispid(pInstaller, "Products");
 517     ok(dispid == 35, "Expected 35, got %d\n", dispid);
 518     todo_wine
 519     {
 520         dispid = get_dispid(pInstaller, "Features");
 521         ok(dispid == 36, "Expected 36, got %d\n", dispid);
 522         dispid = get_dispid(pInstaller, "Components");
 523         ok(dispid == 37, "Expected 37, got %d\n", dispid);
 524         dispid = get_dispid(pInstaller, "ComponentClients");
 525         ok(dispid == 38, "Expected 38, got %d\n", dispid);
 526         dispid = get_dispid(pInstaller, "Patches");
 527         ok(dispid == 39, "Expected 39, got %d\n", dispid);
 528     }
 529     dispid = get_dispid(pInstaller, "RelatedProducts");
 530     ok(dispid == 40, "Expected 40, got %d\n", dispid);
 531     todo_wine
 532     {
 533         dispid = get_dispid(pInstaller, "PatchInfo");
 534         ok(dispid == 41, "Expected 41, got %d\n", dispid);
 535         dispid = get_dispid(pInstaller, "PatchTransforms");
 536         ok(dispid == 42, "Expected 42, got %d\n", dispid);
 537         dispid = get_dispid(pInstaller, "AddSource");
 538         ok(dispid == 43, "Expected 43, got %d\n", dispid);
 539         dispid = get_dispid(pInstaller, "ClearSourceList");
 540         ok(dispid == 44, "Expected 44, got %d\n", dispid);
 541         dispid = get_dispid(pInstaller, "ForceSourceListResolution");
 542         ok(dispid == 45, "Expected 45, got %d\n", dispid);
 543         dispid = get_dispid(pInstaller, "ShortcutTarget");
 544         ok(dispid == 46, "Expected 46, got %d\n", dispid);
 545         dispid = get_dispid(pInstaller, "FileHash");
 546         ok(dispid == 47, "Expected 47, got %d\n", dispid);
 547         dispid = get_dispid(pInstaller, "FileSignatureInfo");
 548         ok(dispid == 48, "Expected 48, got %d\n", dispid);
 549     }
 550     dispid = get_dispid(pInstaller, "RemovePatches");
 551     ok(dispid == 49 || dispid == -1, "Expected 49 or -1, got %d\n", dispid);
 552     dispid = get_dispid(pInstaller, "ApplyMultiplePatches");
 553     ok(dispid == 51 || dispid == -1, "Expected 51 or -1, got %d\n", dispid);
 554     dispid = get_dispid(pInstaller, "ProductsEx");
 555     ok(dispid == 52 || dispid == -1, "Expected 52 or -1, got %d\n", dispid);
 556     dispid = get_dispid(pInstaller, "PatchesEx");
 557     ok(dispid == 55 || dispid == -1, "Expected 55 or -1, got %d\n", dispid);
 558     dispid = get_dispid(pInstaller, "ExtractPatchXMLData");
 559     ok(dispid == 57 || dispid == -1, "Expected 57 or -1, got %d\n", dispid);
 560     dispid = get_dispid( pInstaller, "ProductElevated" );
 561     ok(dispid == 59 || dispid == -1, "Expected 59 or -1, got %d\n", dispid);
 562     dispid = get_dispid( pInstaller, "ProvideAssembly" );
 563     ok(dispid == 60 || dispid == -1, "Expected 60 or -1, got %d\n", dispid);
 564     dispid = get_dispid( pInstaller, "ProductInfoFromScript" );
 565     ok(dispid == 61 || dispid == -1, "Expected 61 or -1, got %d\n", dispid);
 566     dispid = get_dispid( pInstaller, "AdvertiseProduct" );
 567     ok(dispid == 62 || dispid == -1, "Expected 62 or -1, got %d\n", dispid);
 568     dispid = get_dispid( pInstaller, "CreateAdvertiseScript" );
 569     ok(dispid == 63 || dispid == -1, "Expected 63 or -1, got %d\n", dispid);
 570     dispid = get_dispid( pInstaller, "PatchFiles" );
 571     ok(dispid == 65 || dispid == -1, "Expected 65 or -1, got %d\n", dispid);
 572 }
 573
 574 /* Test basic IDispatch functions */
 575 static void test_dispatch(void)
 576 {
 577     static WCHAR szOpenPackage[] = { 'O','p','e','n','P','a','c','k','a','g','e',0 };
 578     static WCHAR szOpenPackageException[] = {'O','p','e','n','P','a','c','k','a','g','e',',','P','a','c','k','a','g','e','P','a','t','h',',','O','p','t','i','o','n','s',0};
 579     static WCHAR szProductState[] = { 'P','r','o','d','u','c','t','S','t','a','t','e',0 };
 580     HRESULT hr;
 581     DISPID dispid;
 582     OLECHAR *name;
 583     VARIANT varresult;
 584     VARIANTARG vararg[2];
 585     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 586
 587     /* Test getting ID of a function name that does not exist */
 588     name = (WCHAR *)szMsifile;
 589     hr = IDispatch_GetIDsOfNames(pInstaller, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 590     ok(hr == DISP_E_UNKNOWNNAME, "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 591
 592     /* Test invoking this function */
 593     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 594     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 595
 596     /* Test getting ID of a function name that does exist */
 597     name = szOpenPackage;
 598     hr = IDispatch_GetIDsOfNames(pInstaller, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 599     ok(hr == S_OK, "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 600
 601     /* Test invoking this function (without parameters passed) */
 602     if (0) /* All of these crash MSI on Windows XP */
 603     {
 604         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 605         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, &excepinfo, NULL);
 606         VariantInit(&varresult);
 607         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, &varresult, &excepinfo, NULL);
 608     }
 609
 610     /* Try with NULL params */
 611     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 612     todo_wine ok(hr == DISP_E_TYPEMISMATCH, "IDispatch::Invoke returned 0x%08x\n", hr);
 613
 614     /* Try one empty parameter */
 615     dispparams.rgvarg = vararg;
 616     dispparams.cArgs = 1;
 617     VariantInit(&vararg[0]);
 618     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 619     todo_wine ok(hr == DISP_E_TYPEMISMATCH, "IDispatch::Invoke returned 0x%08x\n", hr);
 620
 621     /* Try one parameter, function requires two */
 622     VariantInit(&vararg[0]);
 623     V_VT(&vararg[0]) = VT_BSTR;
 624     V_BSTR(&vararg[0]) = SysAllocString(szMsifile);
 625     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 626     VariantClear(&vararg[0]);
 627
 628     ok(hr == DISP_E_EXCEPTION, "IDispatch::Invoke returned 0x%08x\n", hr);
 629     ok_exception(hr, szOpenPackageException);
 630
 631     /* Test invoking a method as a DISPATCH_PROPERTYGET or DISPATCH_PROPERTYPUT */
 632     VariantInit(&vararg[0]);
 633     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dispparams, &varresult, &excepinfo, NULL);
 634     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 635
 636     VariantInit(&vararg[0]);
 637     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 638     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 639
 640     /* Test invoking a read-only property as DISPATCH_PROPERTYPUT or as a DISPATCH_METHOD */
 641     name = szProductState;
 642     hr = IDispatch_GetIDsOfNames(pInstaller, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 643     ok(hr == S_OK, "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 644
 645     dispparams.rgvarg = NULL;
 646     dispparams.cArgs = 0;
 647     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYPUT, &dispparams, &varresult, &excepinfo, NULL);
 648     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 649
 650     dispparams.rgvarg = NULL;
 651     dispparams.cArgs = 0;
 652     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 653     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 654 }
 655
 656 /* invocation helper function */
 657 static int _invoke_todo_vtResult = 0;
 658
 659 static HRESULT invoke(IDispatch *pDispatch, LPCSTR szName, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, VARTYPE vtResult)
 660 {
 661     OLECHAR *name = NULL;
 662     DISPID dispid;
 663     HRESULT hr;
 664     UINT i;
 665     UINT len;
 666
 667     memset(pVarResult, 0, sizeof(VARIANT));
 668     VariantInit(pVarResult);
 669
 670     len = MultiByteToWideChar(CP_ACP, 0, szName, -1, NULL, 0 );
 671     name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR) );
 672     if (!name) return E_FAIL;
 673     len = MultiByteToWideChar(CP_ACP, 0, szName, -1, name, len );
 674     hr = IDispatch_GetIDsOfNames(pDispatch, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 675     HeapFree(GetProcessHeap(), 0, name);
 676     ok(hr == S_OK, "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 677     if (!hr == S_OK) return hr;
 678
 679     memset(&excepinfo, 0, sizeof(excepinfo));
 680     hr = IDispatch_Invoke(pDispatch, dispid, &IID_NULL, LOCALE_NEUTRAL, wFlags, pDispParams, pVarResult, &excepinfo, NULL);
 681
 682     if (hr == S_OK)
 683     {
 684         if (_invoke_todo_vtResult) todo_wine
 685             ok(V_VT(pVarResult) == vtResult, "Variant result type is %d, expected %d\n", V_VT(pVarResult), vtResult);
 686         else
 687             ok(V_VT(pVarResult) == vtResult, "Variant result type is %d, expected %d\n", V_VT(pVarResult), vtResult);
 688         if (vtResult != VT_EMPTY)
 689         {
 690             hr = VariantChangeTypeEx(pVarResult, pVarResult, LOCALE_NEUTRAL, 0, vtResult);
 691             ok(hr == S_OK, "VariantChangeTypeEx returned 0x%08x\n", hr);
 692         }
 693     }
 694
 695     for (i=0; i<pDispParams->cArgs; i++)
 696         VariantClear(&pDispParams->rgvarg[i]);
 697
 698     return hr;
 699 }
 700
 701 /* Object_Property helper functions */
 702
 703 static HRESULT Installer_CreateRecord(int count, IDispatch **pRecord)
 704 {
 705     VARIANT varresult;
 706     VARIANTARG vararg[1];
 707     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 708     HRESULT hr;
 709
 710     VariantInit(&vararg[0]);
 711     V_VT(&vararg[0]) = VT_I4;
 712     V_I4(&vararg[0]) = count;
 713
 714     hr = invoke(pInstaller, "CreateRecord", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 715     *pRecord = V_DISPATCH(&varresult);
 716     return hr;
 717 }
 718
 719 static HRESULT Installer_RegistryValue(HKEY hkey, LPCWSTR szKey, VARIANT vValue, VARIANT *pVarResult, VARTYPE vtExpect)
 720 {
 721     VARIANTARG vararg[3];
 722     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 723
 724     VariantInit(&vararg[2]);
 725     V_VT(&vararg[2]) = VT_I4;
 726     V_I4(&vararg[2]) = (INT_PTR)hkey;
 727     VariantInit(&vararg[1]);
 728     V_VT(&vararg[1]) = VT_BSTR;
 729     V_BSTR(&vararg[1]) = SysAllocString(szKey);
 730     VariantInit(&vararg[0]);
 731     VariantCopy(&vararg[0], &vValue);
 732     VariantClear(&vValue);
 733
 734     return invoke(pInstaller, "RegistryValue", DISPATCH_METHOD, &dispparams, pVarResult, vtExpect);
 735 }
 736
 737 static HRESULT Installer_RegistryValueE(HKEY hkey, LPCWSTR szKey, BOOL *pBool)
 738 {
 739     VARIANT varresult;
 740     VARIANTARG vararg;
 741     HRESULT hr;
 742
 743     VariantInit(&vararg);
 744     V_VT(&vararg) = VT_EMPTY;
 745     hr = Installer_RegistryValue(hkey, szKey, vararg, &varresult, VT_BOOL);
 746     *pBool = V_BOOL(&varresult);
 747     VariantClear(&varresult);
 748     return hr;
 749 }
 750
 751 static HRESULT Installer_RegistryValueW(HKEY hkey, LPCWSTR szKey, LPCWSTR szValue, LPWSTR szString)
 752 {
 753     VARIANT varresult;
 754     VARIANTARG vararg;
 755     HRESULT hr;
 756
 757     VariantInit(&vararg);
 758     V_VT(&vararg) = VT_BSTR;
 759     V_BSTR(&vararg) = SysAllocString(szValue);
 760
 761     hr = Installer_RegistryValue(hkey, szKey, vararg, &varresult, VT_BSTR);
 762     if (V_BSTR(&varresult)) lstrcpyW(szString, V_BSTR(&varresult));
 763     VariantClear(&varresult);
 764     return hr;
 765 }
 766
 767 static HRESULT Installer_RegistryValueI(HKEY hkey, LPCWSTR szKey, int iValue, LPWSTR szString, VARTYPE vtResult)
 768 {
 769     VARIANT varresult;
 770     VARIANTARG vararg;
 771     HRESULT hr;
 772
 773     VariantInit(&vararg);
 774     V_VT(&vararg) = VT_I4;
 775     V_I4(&vararg) = iValue;
 776
 777     hr = Installer_RegistryValue(hkey, szKey, vararg, &varresult, vtResult);
 778     if (SUCCEEDED(hr) && vtResult == VT_BSTR) lstrcpyW(szString, V_BSTR(&varresult));
 779     VariantClear(&varresult);
 780     return hr;
 781 }
 782
 783 static HRESULT Installer_OpenPackage(LPCWSTR szPackagePath, int options, IDispatch **pSession)
 784 {
 785     VARIANT varresult;
 786     VARIANTARG vararg[2];
 787     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 788     HRESULT hr;
 789
 790     VariantInit(&vararg[1]);
 791     V_VT(&vararg[1]) = VT_BSTR;
 792     V_BSTR(&vararg[1]) = SysAllocString(szPackagePath);
 793     VariantInit(&vararg[0]);
 794     V_VT(&vararg[0]) = VT_I4;
 795     V_I4(&vararg[0]) = options;
 796
 797     hr = invoke(pInstaller, "OpenPackage", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 798     *pSession = V_DISPATCH(&varresult);
 799     return hr;
 800 }
 801
 802 static HRESULT Installer_OpenDatabase(LPCWSTR szDatabasePath, int openmode, IDispatch **pDatabase)
 803 {
 804     VARIANT varresult;
 805     VARIANTARG vararg[2];
 806     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 807     HRESULT hr;
 808
 809     VariantInit(&vararg[1]);
 810     V_VT(&vararg[1]) = VT_BSTR;
 811     V_BSTR(&vararg[1]) = SysAllocString(szDatabasePath);
 812     VariantInit(&vararg[0]);
 813     V_VT(&vararg[0]) = VT_I4;
 814     V_I4(&vararg[0]) = openmode;
 815
 816     hr = invoke(pInstaller, "OpenDatabase", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 817     *pDatabase = V_DISPATCH(&varresult);
 818     return hr;
 819 }
 820
 821 static HRESULT Installer_InstallProduct(LPCWSTR szPackagePath, LPCWSTR szPropertyValues)
 822 {
 823     VARIANT varresult;
 824     VARIANTARG vararg[2];
 825     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 826
 827     VariantInit(&vararg[1]);
 828     V_VT(&vararg[1]) = VT_BSTR;
 829     V_BSTR(&vararg[1]) = SysAllocString(szPackagePath);
 830     VariantInit(&vararg[0]);
 831     V_VT(&vararg[0]) = VT_BSTR;
 832     V_BSTR(&vararg[0]) = SysAllocString(szPropertyValues);
 833
 834     return invoke(pInstaller, "InstallProduct", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
 835 }
 836
 837 static HRESULT Installer_ProductState(LPCWSTR szProduct, int *pInstallState)
 838 {
 839     VARIANT varresult;
 840     VARIANTARG vararg[1];
 841     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 842     HRESULT hr;
 843
 844     VariantInit(&vararg[0]);
 845     V_VT(&vararg[0]) = VT_BSTR;
 846     V_BSTR(&vararg[0]) = SysAllocString(szProduct);
 847
 848     hr = invoke(pInstaller, "ProductState", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 849     *pInstallState = V_I4(&varresult);
 850     VariantClear(&varresult);
 851     return hr;
 852 }
 853
 854 static HRESULT Installer_ProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute, LPWSTR szString)
 855 {
 856     VARIANT varresult;
 857     VARIANTARG vararg[2];
 858     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 859     HRESULT hr;
 860
 861     VariantInit(&vararg[1]);
 862     V_VT(&vararg[1]) = VT_BSTR;
 863     V_BSTR(&vararg[1]) = SysAllocString(szProduct);
 864     VariantInit(&vararg[0]);
 865     V_VT(&vararg[0]) = VT_BSTR;
 866     V_BSTR(&vararg[0]) = SysAllocString(szAttribute);
 867
 868     hr = invoke(pInstaller, "ProductInfo", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 869     if (V_BSTR(&varresult)) lstrcpyW(szString, V_BSTR(&varresult));
 870     VariantClear(&varresult);
 871     return hr;
 872 }
 873
 874 static HRESULT Installer_Products(IDispatch **pStringList)
 875 {
 876     VARIANT varresult;
 877     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 878     HRESULT hr;
 879
 880     hr = invoke(pInstaller, "Products", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
 881     *pStringList = V_DISPATCH(&varresult);
 882     return hr;
 883 }
 884
 885 static HRESULT Installer_RelatedProducts(LPCWSTR szProduct, IDispatch **pStringList)
 886 {
 887     VARIANT varresult;
 888     VARIANTARG vararg[1];
 889     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 890     HRESULT hr;
 891
 892     VariantInit(&vararg[0]);
 893     V_VT(&vararg[0]) = VT_BSTR;
 894     V_BSTR(&vararg[0]) = SysAllocString(szProduct);
 895
 896     hr = invoke(pInstaller, "RelatedProducts", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
 897     *pStringList = V_DISPATCH(&varresult);
 898     return hr;
 899 }
 900
 901 static HRESULT Installer_VersionGet(LPWSTR szVersion)
 902 {
 903     VARIANT varresult;
 904     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 905     HRESULT hr;
 906
 907     hr = invoke(pInstaller, "Version", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 908     if (V_BSTR(&varresult)) lstrcpyW(szVersion, V_BSTR(&varresult));
 909     VariantClear(&varresult);
 910     return hr;
 911 }
 912
 913 static HRESULT Session_Installer(IDispatch *pSession, IDispatch **pInst)
 914 {
 915     VARIANT varresult;
 916     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 917     HRESULT hr;
 918
 919     hr = invoke(pSession, "Installer", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
 920     *pInst = V_DISPATCH(&varresult);
 921     return hr;
 922 }
 923
 924 static HRESULT Session_PropertyGet(IDispatch *pSession, LPCWSTR szName, LPWSTR szReturn)
 925 {
 926     VARIANT varresult;
 927     VARIANTARG vararg[1];
 928     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 929     HRESULT hr;
 930
 931     VariantInit(&vararg[0]);
 932     V_VT(&vararg[0]) = VT_BSTR;
 933     V_BSTR(&vararg[0]) = SysAllocString(szName);
 934
 935     hr = invoke(pSession, "Property", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 936     if (V_BSTR(&varresult)) lstrcpyW(szReturn, V_BSTR(&varresult));
 937     VariantClear(&varresult);
 938     return hr;
 939 }
 940
 941 static HRESULT Session_PropertyPut(IDispatch *pSession, LPCWSTR szName, LPCWSTR szValue)
 942 {
 943     VARIANT varresult;
 944     VARIANTARG vararg[2];
 945     DISPID dispid = DISPID_PROPERTYPUT;
 946     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 947
 948     VariantInit(&vararg[1]);
 949     V_VT(&vararg[1]) = VT_BSTR;
 950     V_BSTR(&vararg[1]) = SysAllocString(szName);
 951     VariantInit(&vararg[0]);
 952     V_VT(&vararg[0]) = VT_BSTR;
 953     V_BSTR(&vararg[0]) = SysAllocString(szValue);
 954
 955     return invoke(pSession, "Property", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
 956 }
 957
 958 static HRESULT Session_LanguageGet(IDispatch *pSession, UINT *pLangId)
 959 {
 960     VARIANT varresult;
 961     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 962     HRESULT hr;
 963
 964     hr = invoke(pSession, "Language", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 965     *pLangId = V_I4(&varresult);
 966     VariantClear(&varresult);
 967     return hr;
 968 }
 969
 970 static HRESULT Session_ModeGet(IDispatch *pSession, int iFlag, BOOL *pMode)
 971 {
 972     VARIANT varresult;
 973     VARIANTARG vararg[1];
 974     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 975     HRESULT hr;
 976
 977     VariantInit(&vararg[0]);
 978     V_VT(&vararg[0]) = VT_I4;
 979     V_I4(&vararg[0]) = iFlag;
 980
 981     hr = invoke(pSession, "Mode", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BOOL);
 982     *pMode = V_BOOL(&varresult);
 983     VariantClear(&varresult);
 984     return hr;
 985 }
 986
 987 static HRESULT Session_ModePut(IDispatch *pSession, int iFlag, BOOL bMode)
 988 {
 989     VARIANT varresult;
 990     VARIANTARG vararg[2];
 991     DISPID dispid = DISPID_PROPERTYPUT;
 992     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 993
 994     VariantInit(&vararg[1]);
 995     V_VT(&vararg[1]) = VT_I4;
 996     V_I4(&vararg[1]) = iFlag;
 997     VariantInit(&vararg[0]);
 998     V_VT(&vararg[0]) = VT_BOOL;
 999     V_BOOL(&vararg[0]) = bMode;
1000
1001     return invoke(pSession, "Mode", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
1002 }
1003
1004 static HRESULT Session_Database(IDispatch *pSession, IDispatch **pDatabase)
1005 {
1006     VARIANT varresult;
1007     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1008     HRESULT hr;
1009
1010     hr = invoke(pSession, "Database", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
1011     *pDatabase = V_DISPATCH(&varresult);
1012     return hr;
1013 }
1014
1015 static HRESULT Session_DoAction(IDispatch *pSession, LPCWSTR szAction, int *iReturn)
1016 {
1017     VARIANT varresult;
1018     VARIANTARG vararg[1];
1019     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1020     HRESULT hr;
1021
1022     VariantInit(&vararg[0]);
1023     V_VT(&vararg[0]) = VT_BSTR;
1024     V_BSTR(&vararg[0]) = SysAllocString(szAction);
1025
1026     hr = invoke(pSession, "DoAction", DISPATCH_METHOD, &dispparams, &varresult, VT_I4);
1027     *iReturn = V_I4(&varresult);
1028     VariantClear(&varresult);
1029     return hr;
1030 }
1031
1032 static HRESULT Session_EvaluateCondition(IDispatch *pSession, LPCWSTR szCondition, int *iReturn)
1033 {
1034     VARIANT varresult;
1035     VARIANTARG vararg[1];
1036     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1037     HRESULT hr;
1038
1039     VariantInit(&vararg[0]);
1040     V_VT(&vararg[0]) = VT_BSTR;
1041     V_BSTR(&vararg[0]) = SysAllocString(szCondition);
1042
1043     hr = invoke(pSession, "EvaluateCondition", DISPATCH_METHOD, &dispparams, &varresult, VT_I4);
1044     *iReturn = V_I4(&varresult);
1045     VariantClear(&varresult);
1046     return hr;
1047 }
1048
1049 static HRESULT Session_Message(IDispatch *pSession, long kind, IDispatch *record, int *ret)
1050 {
1051     VARIANT varresult;
1052     VARIANTARG vararg[2];
1053     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1054     HRESULT hr;
1055
1056     VariantInit(&varresult);
1057     V_VT(vararg) = VT_DISPATCH;
1058     V_DISPATCH(vararg) = record;
1059     V_VT(vararg+1) = VT_I4;
1060     V_I4(vararg+1) = kind;
1061
1062     hr = invoke(pSession, "Message", DISPATCH_METHOD, &dispparams, &varresult, VT_I4);
1063
1064     ok(V_VT(&varresult) == VT_I4, "V_VT(varresult) = %d\n", V_VT(&varresult));
1065     *ret = V_I4(&varresult);
1066
1067     return hr;
1068 }
1069
1070 static HRESULT Session_SetInstallLevel(IDispatch *pSession, long iInstallLevel)
1071 {
1072     VARIANT varresult;
1073     VARIANTARG vararg[1];
1074     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1075
1076     VariantInit(&vararg[0]);
1077     V_VT(&vararg[0]) = VT_I4;
1078     V_I4(&vararg[0]) = iInstallLevel;
1079
1080     return invoke(pSession, "SetInstallLevel", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
1081 }
1082
1083 static HRESULT Session_FeatureCurrentState(IDispatch *pSession, LPCWSTR szName, int *pState)
1084 {
1085     VARIANT varresult;
1086     VARIANTARG vararg[1];
1087     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1088     HRESULT hr;
1089
1090     VariantInit(&vararg[0]);
1091     V_VT(&vararg[0]) = VT_BSTR;
1092     V_BSTR(&vararg[0]) = SysAllocString(szName);
1093
1094     hr = invoke(pSession, "FeatureCurrentState", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1095     *pState = V_I4(&varresult);
1096     VariantClear(&varresult);
1097     return hr;
1098 }
1099
1100 static HRESULT Session_FeatureRequestStateGet(IDispatch *pSession, LPCWSTR szName, int *pState)
1101 {
1102     VARIANT varresult;
1103     VARIANTARG vararg[1];
1104     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1105     HRESULT hr;
1106
1107     VariantInit(&vararg[0]);
1108     V_VT(&vararg[0]) = VT_BSTR;
1109     V_BSTR(&vararg[0]) = SysAllocString(szName);
1110
1111     hr = invoke(pSession, "FeatureRequestState", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1112     *pState = V_I4(&varresult);
1113     VariantClear(&varresult);
1114     return hr;
1115 }
1116
1117 static HRESULT Session_FeatureRequestStatePut(IDispatch *pSession, LPCWSTR szName, int iState)
1118 {
1119     VARIANT varresult;
1120     VARIANTARG vararg[2];
1121     DISPID dispid = DISPID_PROPERTYPUT;
1122     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
1123
1124     VariantInit(&vararg[1]);
1125     V_VT(&vararg[1]) = VT_BSTR;
1126     V_BSTR(&vararg[1]) = SysAllocString(szName);
1127     VariantInit(&vararg[0]);
1128     V_VT(&vararg[0]) = VT_I4;
1129     V_I4(&vararg[0]) = iState;
1130
1131     return invoke(pSession, "FeatureRequestState", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
1132 }
1133
1134 static HRESULT Database_OpenView(IDispatch *pDatabase, LPCWSTR szSql, IDispatch **pView)
1135 {
1136     VARIANT varresult;
1137     VARIANTARG vararg[1];
1138     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1139     HRESULT hr;
1140
1141     VariantInit(&vararg[0]);
1142     V_VT(&vararg[0]) = VT_BSTR;
1143     V_BSTR(&vararg[0]) = SysAllocString(szSql);
1144
1145     hr = invoke(pDatabase, "OpenView", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
1146     *pView = V_DISPATCH(&varresult);
1147     return hr;
1148 }
1149
1150 static HRESULT Database_SummaryInformation(IDispatch *pDatabase, int iUpdateCount, IDispatch **pSummaryInfo)
1151 {
1152     VARIANT varresult;
1153     VARIANTARG vararg[1];
1154     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1155     HRESULT hr;
1156
1157     VariantInit(&vararg[0]);
1158     V_VT(&vararg[0]) = VT_I4;
1159     V_I4(&vararg[0]) = iUpdateCount;
1160
1161     hr = invoke(pDatabase, "SummaryInformation", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
1162     *pSummaryInfo = V_DISPATCH(&varresult);
1163     return hr;
1164 }
1165
1166 static HRESULT View_Execute(IDispatch *pView, IDispatch *pRecord)
1167 {
1168     VARIANT varresult;
1169     VARIANTARG vararg[1];
1170     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1171
1172     VariantInit(&vararg[0]);
1173     V_VT(&vararg[0]) = VT_DISPATCH;
1174     V_DISPATCH(&vararg[0]) = pRecord;
1175
1176     return invoke(pView, "Execute", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
1177 }
1178
1179 static HRESULT View_Fetch(IDispatch *pView, IDispatch **ppRecord)
1180 {
1181     VARIANT varresult;
1182     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1183     HRESULT hr = invoke(pView, "Fetch", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
1184     *ppRecord = V_DISPATCH(&varresult);
1185     return hr;
1186 }
1187
1188 static HRESULT View_Modify(IDispatch *pView, int iMode, IDispatch *pRecord)
1189 {
1190     VARIANT varresult;
1191     VARIANTARG vararg[2];
1192     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1193
1194     VariantInit(&vararg[1]);
1195     V_VT(&vararg[1]) = VT_I4;
1196     V_I4(&vararg[1]) = iMode;
1197     VariantInit(&vararg[0]);
1198     V_VT(&vararg[0]) = VT_DISPATCH;
1199     V_DISPATCH(&vararg[0]) = pRecord;
1200     if (pRecord)
1201         IDispatch_AddRef(pRecord);   /* VariantClear in invoke will call IDispatch_Release */
1202
1203     return invoke(pView, "Modify", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
1204 }
1205
1206 static HRESULT View_Close(IDispatch *pView)
1207 {
1208     VARIANT varresult;
1209     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1210     return invoke(pView, "Close", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
1211 }
1212
1213 static HRESULT Record_FieldCountGet(IDispatch *pRecord, int *pFieldCount)
1214 {
1215     VARIANT varresult;
1216     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1217     HRESULT hr = invoke(pRecord, "FieldCount", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1218     *pFieldCount = V_I4(&varresult);
1219     VariantClear(&varresult);
1220     return hr;
1221 }
1222
1223 static HRESULT Record_StringDataGet(IDispatch *pRecord, int iField, LPWSTR szString)
1224 {
1225     VARIANT varresult;
1226     VARIANTARG vararg[1];
1227     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1228     HRESULT hr;
1229
1230     VariantInit(&vararg[0]);
1231     V_VT(&vararg[0]) = VT_I4;
1232     V_I4(&vararg[0]) = iField;
1233
1234     hr = invoke(pRecord, "StringData", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
1235     if (V_BSTR(&varresult)) lstrcpyW(szString, V_BSTR(&varresult));
1236     VariantClear(&varresult);
1237     return hr;
1238 }
1239
1240 static HRESULT Record_StringDataPut(IDispatch *pRecord, int iField, LPCWSTR szString)
1241 {
1242     VARIANT varresult;
1243     VARIANTARG vararg[2];
1244     DISPID dispid = DISPID_PROPERTYPUT;
1245     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
1246
1247     VariantInit(&vararg[1]);
1248     V_VT(&vararg[1]) = VT_I4;
1249     V_I4(&vararg[1]) = iField;
1250     VariantInit(&vararg[0]);
1251     V_VT(&vararg[0]) = VT_BSTR;
1252     V_BSTR(&vararg[0]) = SysAllocString(szString);
1253
1254     return invoke(pRecord, "StringData", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
1255 }
1256
1257 static HRESULT Record_IntegerDataGet(IDispatch *pRecord, int iField, int *pValue)
1258 {
1259     VARIANT varresult;
1260     VARIANTARG vararg[1];
1261     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1262     HRESULT hr;
1263
1264     VariantInit(&vararg[0]);
1265     V_VT(&vararg[0]) = VT_I4;
1266     V_I4(&vararg[0]) = iField;
1267
1268     hr = invoke(pRecord, "IntegerData", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1269     *pValue = V_I4(&varresult);
1270     VariantClear(&varresult);
1271     return hr;
1272 }
1273
1274 static HRESULT Record_IntegerDataPut(IDispatch *pRecord, int iField, int iValue)
1275 {
1276     VARIANT varresult;
1277     VARIANTARG vararg[2];
1278     DISPID dispid = DISPID_PROPERTYPUT;
1279     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
1280
1281     VariantInit(&vararg[1]);
1282     V_VT(&vararg[1]) = VT_I4;
1283     V_I4(&vararg[1]) = iField;
1284     VariantInit(&vararg[0]);
1285     V_VT(&vararg[0]) = VT_I4;
1286     V_I4(&vararg[0]) = iValue;
1287
1288     return invoke(pRecord, "IntegerData", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
1289 }
1290
1291 static HRESULT StringList__NewEnum(IDispatch *pList, IUnknown **ppEnumVARIANT)
1292 {
1293     VARIANT varresult;
1294     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1295     HRESULT hr = invoke(pList, "_NewEnum", DISPATCH_METHOD, &dispparams, &varresult, VT_UNKNOWN);
1296     *ppEnumVARIANT = V_UNKNOWN(&varresult);
1297     return hr;
1298 }
1299
1300 static HRESULT StringList_Item(IDispatch *pStringList, int iIndex, LPWSTR szString)
1301 {
1302     VARIANT varresult;
1303     VARIANTARG vararg[1];
1304     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1305     HRESULT hr;
1306
1307     VariantInit(&vararg[0]);
1308     V_VT(&vararg[0]) = VT_I4;
1309     V_I4(&vararg[0]) = iIndex;
1310
1311     hr = invoke(pStringList, "Item", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
1312     if (V_BSTR(&varresult)) lstrcpyW(szString, V_BSTR(&varresult));
1313     VariantClear(&varresult);
1314     return hr;
1315 }
1316
1317 static HRESULT StringList_Count(IDispatch *pStringList, int *pCount)
1318 {
1319     VARIANT varresult;
1320     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1321     HRESULT hr = invoke(pStringList, "Count", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1322     *pCount = V_I4(&varresult);
1323     VariantClear(&varresult);
1324     return hr;
1325 }
1326
1327 static HRESULT SummaryInfo_PropertyGet(IDispatch *pSummaryInfo, int pid, VARIANT *pVarResult, VARTYPE vtExpect)
1328 {
1329     VARIANTARG vararg[1];
1330     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
1331
1332     VariantInit(&vararg[0]);
1333     V_VT(&vararg[0]) = VT_I4;
1334     V_I4(&vararg[0]) = pid;
1335     return invoke(pSummaryInfo, "Property", DISPATCH_PROPERTYGET, &dispparams, pVarResult, vtExpect);
1336 }
1337
1338 static HRESULT SummaryInfo_PropertyPut(IDispatch *pSummaryInfo, int pid, VARIANT *pVariant)
1339 {
1340     VARIANT varresult;
1341     VARIANTARG vararg[2];
1342     DISPID dispid = DISPID_PROPERTYPUT;
1343     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
1344
1345     VariantInit(&vararg[1]);
1346     V_VT(&vararg[1]) = VT_I4;
1347     V_I4(&vararg[1]) = pid;
1348     VariantInit(&vararg[0]);
1349     VariantCopyInd(vararg, pVariant);
1350
1351     return invoke(pSummaryInfo, "Property", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
1352 }
1353
1354 static HRESULT SummaryInfo_PropertyCountGet(IDispatch *pSummaryInfo, int *pCount)
1355 {
1356     VARIANT varresult;
1357     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
1358     HRESULT hr;
1359
1360     hr = invoke(pSummaryInfo, "PropertyCount", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
1361     *pCount = V_I4(&varresult);
1362     VariantClear(&varresult);
1363     return hr;
1364 }
1365
1366 /* Test the various objects */
1367
1368 #define TEST_SUMMARYINFO_PROPERTIES_MODIFIED 4
1369
1370 static void test_SummaryInfo(IDispatch *pSummaryInfo, const msi_summary_info *info, int num_info, BOOL readonly)
1371 {
1372     static const WCHAR szPropertyException[] = { 'P','r','o','p','e','r','t','y',',','P','i','d',0 };
1373     static const WCHAR szTitle[] = { 'T','i','t','l','e',0 };
1374     VARIANT varresult, var;
1375     SYSTEMTIME st;
1376     HRESULT hr;
1377     int j;
1378
1379     /* SummaryInfo::PropertyCount */
1380     hr = SummaryInfo_PropertyCountGet(pSummaryInfo, &j);
1381     ok(hr == S_OK, "SummaryInfo_PropertyCount failed, hresult 0x%08x\n", hr);
1382     ok(j == num_info, "SummaryInfo_PropertyCount returned %d, expected %d\n", j, num_info);
1383
1384     /* SummaryInfo::Property, get for properties we have set */
1385     for (j = 0; j < num_info; j++)
1386     {
1387         const msi_summary_info *entry = &info[j];
1388
1389         int vt = entry->datatype;
1390         if (vt == VT_LPSTR) vt = VT_BSTR;
1391         else if (vt == VT_FILETIME) vt = VT_DATE;
1392         else if (vt == VT_I2) vt = VT_I4;
1393
1394         hr = SummaryInfo_PropertyGet(pSummaryInfo, entry->property, &varresult, vt);
1395         ok(hr == S_OK, "SummaryInfo_Property (pid %d) failed, hresult 0x%08x\n", entry->property, hr);
1396         if (V_VT(&varresult) != vt)
1397             skip("Skipping property tests due to type mismatch\n");
1398         else if (vt == VT_I4)
1399             ok(V_I4(&varresult) == entry->iValue, "SummaryInfo_Property (pid %d) I4 result expected to be %d, but was %d\n",
1400                entry->property, entry->iValue, V_I4(&varresult));
1401         else if (vt == VT_DATE)
1402         {
1403             FILETIME ft;
1404             DATE d;
1405
1406             FileTimeToLocalFileTime(entry->pftValue, &ft);
1407             FileTimeToSystemTime(&ft, &st);
1408             SystemTimeToVariantTime(&st, &d);
1409             ok(d == V_DATE(&varresult), "SummaryInfo_Property (pid %d) DATE result expected to be %lf, but was %lf\n", entry->property, d, V_DATE(&varresult));
1410         }
1411         else if (vt == VT_BSTR)
1412         {
1413             ok_awplus("SummaryInfo_Property (pid %d) BSTR result expected to be %s, but was %s\n", entry->property, entry->szValue, V_BSTR(&varresult));
1414         }
1415         else
1416             skip("SummaryInfo_Property (pid %d) unhandled result type %d\n", entry->property, vt);
1417
1418         VariantClear(&varresult);
1419     }
1420
1421     /* SummaryInfo::Property, get; invalid arguments */
1422
1423     /* Invalid pids */
1424     hr = SummaryInfo_PropertyGet(pSummaryInfo, -1, &varresult, VT_EMPTY);
1425     ok(hr == DISP_E_EXCEPTION, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1426     ok_exception(hr, szPropertyException);
1427
1428     hr = SummaryInfo_PropertyGet(pSummaryInfo, 1000, &varresult, VT_EMPTY);
1429     ok(hr == DISP_E_EXCEPTION, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1430     ok_exception(hr, szPropertyException);
1431
1432     /* Unsupported pids */
1433     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_DICTIONARY, &varresult, VT_EMPTY);
1434     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1435
1436     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_THUMBNAIL, &varresult, VT_EMPTY);
1437     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1438
1439     /* Pids we have not set, one for each type */
1440     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_CODEPAGE, &varresult, VT_EMPTY);
1441     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1442
1443     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_TITLE, &varresult, VT_EMPTY);
1444     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1445
1446     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_EDITTIME, &varresult, VT_EMPTY);
1447     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1448
1449     hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_CHARCOUNT, &varresult, VT_EMPTY);
1450     ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1451
1452     if (!readonly)
1453     {
1454         /* SummaryInfo::Property, put; one for each type */
1455
1456         /* VT_I2 */
1457         VariantInit(&var);
1458         V_VT(&var) = VT_I2;
1459         V_I2(&var) = 1;
1460         hr = SummaryInfo_PropertyPut(pSummaryInfo, PID_CODEPAGE, &var);
1461         ok(hr == S_OK, "SummaryInfo_PropertyPut failed, hresult 0x%08x\n", hr);
1462
1463         hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_CODEPAGE, &varresult, VT_I4 /* NOT VT_I2 */);
1464         ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1465         ok(V_I2(&var) == V_I2(&varresult), "SummaryInfo_PropertyGet expected %d, but returned %d\n", V_I2(&var), V_I2(&varresult));
1466         VariantClear(&varresult);
1467         VariantClear(&var);
1468
1469         /* VT_BSTR */
1470         V_VT(&var) = VT_BSTR;
1471         V_BSTR(&var) = SysAllocString(szTitle);
1472         hr = SummaryInfo_PropertyPut(pSummaryInfo, PID_TITLE, &var);
1473         ok(hr == S_OK, "SummaryInfo_PropertyPut failed, hresult 0x%08x\n", hr);
1474
1475         hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_TITLE, &varresult, V_VT(&var));
1476         ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1477         ok_w2("SummaryInfo_PropertyGet expected %s, but returned %s\n", V_BSTR(&var), V_BSTR(&varresult));
1478         VariantClear(&varresult);
1479         VariantClear(&var);
1480
1481         /* VT_DATE */
1482         V_VT(&var) = VT_DATE;
1483         FileTimeToSystemTime(&systemtime, &st);
1484         SystemTimeToVariantTime(&st, &V_DATE(&var));
1485         hr = SummaryInfo_PropertyPut(pSummaryInfo, PID_LASTSAVE_DTM, &var);
1486         ok(hr == S_OK, "SummaryInfo_PropertyPut failed, hresult 0x%08x\n", hr);
1487
1488         hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_LASTSAVE_DTM, &varresult, V_VT(&var));
1489         ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1490         /* FIXME: Off by one second */
1491         todo_wine ok(V_DATE(&var) == V_DATE(&varresult), "SummaryInfo_PropertyGet expected %lf, but returned %lf\n", V_DATE(&var), V_DATE(&varresult));
1492         VariantClear(&varresult);
1493         VariantClear(&var);
1494
1495         /* VT_I4 */
1496         V_VT(&var) = VT_I4;
1497         V_I4(&var) = 1000;
1498         hr = SummaryInfo_PropertyPut(pSummaryInfo, PID_CHARCOUNT, &var);
1499         ok(hr == S_OK, "SummaryInfo_PropertyPut failed, hresult 0x%08x\n", hr);
1500
1501         hr = SummaryInfo_PropertyGet(pSummaryInfo, PID_CHARCOUNT, &varresult, V_VT(&var));
1502         ok(hr == S_OK, "SummaryInfo_PropertyGet failed, hresult 0x%08x\n", hr);
1503         ok(V_I4(&var) == V_I4(&varresult), "SummaryInfo_PropertyGet expected %d, but returned %d\n", V_I4(&var), V_I4(&varresult));
1504         VariantClear(&varresult);
1505         VariantClear(&var);
1506
1507         /* SummaryInfo::PropertyCount */
1508         hr = SummaryInfo_PropertyCountGet(pSummaryInfo, &j);
1509         ok(hr == S_OK, "SummaryInfo_PropertyCount failed, hresult 0x%08x\n", hr);
1510         ok(j == num_info+4, "SummaryInfo_PropertyCount returned %d, expected %d\n", j, num_info);
1511     }
1512 }
1513
1514 static void test_Database(IDispatch *pDatabase, BOOL readonly)
1515 {
1516     static WCHAR szSql[] = { 'S','E','L','E','C','T',' ','`','F','e','a','t','u','r','e','`',' ','F','R','O','M',' ','`','F','e','a','t','u','r','e','`',' ','W','H','E','R','E',' ','`','F','e','a','t','u','r','e','_','P','a','r','e','n','t','`','=','\'','O','n','e','\'',0 };
1517     static WCHAR szThree[] = { 'T','h','r','e','e',0 };
1518     static WCHAR szTwo[] = { 'T','w','o',0 };
1519     static WCHAR szStringDataField[] = { 'S','t','r','i','n','g','D','a','t','a',',','F','i','e','l','d',0 };
1520     static WCHAR szModifyModeRecord[] = { 'M','o','d','i','f','y',',','M','o','d','e',',','R','e','c','o','r','d',0 };
1521     IDispatch *pView = NULL, *pSummaryInfo = NULL;
1522     HRESULT hr;
1523
1524     hr = Database_OpenView(pDatabase, szSql, &pView);
1525     ok(hr == S_OK, "Database_OpenView failed, hresult 0x%08x\n", hr);
1526     if (hr == S_OK)
1527     {
1528         IDispatch *pRecord = NULL;
1529         WCHAR szString[MAX_PATH];
1530
1531         /* View::Execute */
1532         hr = View_Execute(pView, NULL);
1533         ok(hr == S_OK, "View_Execute failed, hresult 0x%08x\n", hr);
1534
1535         /* View::Fetch */
1536         hr = View_Fetch(pView, &pRecord);
1537         ok(hr == S_OK, "View_Fetch failed, hresult 0x%08x\n", hr);
1538         ok(pRecord != NULL, "View_Fetch should not have returned NULL record\n");
1539         if (pRecord)
1540         {
1541             /* Record::StringDataGet */
1542             memset(szString, 0, sizeof(szString));
1543             hr = Record_StringDataGet(pRecord, 1, szString);
1544             ok(hr == S_OK, "Record_StringDataGet failed, hresult 0x%08x\n", hr);
1545             ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szThree);
1546
1547             /* Record::StringDataPut with correct index */
1548             hr = Record_StringDataPut(pRecord, 1, szTwo);
1549             ok(hr == S_OK, "Record_StringDataPut failed, hresult 0x%08x\n", hr);
1550
1551             /* Record::StringDataGet */
1552             memset(szString, 0, sizeof(szString));
1553             hr = Record_StringDataGet(pRecord, 1, szString);
1554             ok(hr == S_OK, "Record_StringDataGet failed, hresult 0x%08x\n", hr);
1555             ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szTwo);
1556
1557             /* Record::StringDataPut with incorrect index */
1558             hr = Record_StringDataPut(pRecord, -1, szString);
1559             ok(hr == DISP_E_EXCEPTION, "Record_StringDataPut failed, hresult 0x%08x\n", hr);
1560             ok_exception(hr, szStringDataField);
1561
1562             /* View::Modify with incorrect parameters */
1563             hr = View_Modify(pView, -5, NULL);
1564             ok(hr == DISP_E_EXCEPTION, "View_Modify failed, hresult 0x%08x\n", hr);
1565             ok_exception(hr, szModifyModeRecord);
1566
1567             hr = View_Modify(pView, -5, pRecord);
1568             ok(hr == DISP_E_EXCEPTION, "View_Modify failed, hresult 0x%08x\n", hr);
1569             ok_exception(hr, szModifyModeRecord);
1570
1571             hr = View_Modify(pView, MSIMODIFY_REFRESH, NULL);
1572             ok(hr == DISP_E_EXCEPTION, "View_Modify failed, hresult 0x%08x\n", hr);
1573             ok_exception(hr, szModifyModeRecord);
1574
1575             hr = View_Modify(pView, MSIMODIFY_REFRESH, pRecord);
1576             ok(hr == S_OK, "View_Modify failed, hresult 0x%08x\n", hr);
1577
1578             /* Record::StringDataGet, confirm that the record is back to its unmodified value */
1579             memset(szString, 0, sizeof(szString));
1580             hr = Record_StringDataGet(pRecord, 1, szString);
1581             ok(hr == S_OK, "Record_StringDataGet failed, hresult 0x%08x\n", hr);
1582             todo_wine ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szThree);
1583
1584             IDispatch_Release(pRecord);
1585         }
1586
1587         /* View::Fetch */
1588         hr = View_Fetch(pView, &pRecord);
1589         ok(hr == S_OK, "View_Fetch failed, hresult 0x%08x\n", hr);
1590         ok(pRecord != NULL, "View_Fetch should not have returned NULL record\n");
1591         if (pRecord)
1592         {
1593             /* Record::StringDataGet */
1594             memset(szString, 0, sizeof(szString));
1595             hr = Record_StringDataGet(pRecord, 1, szString);
1596             ok(hr == S_OK, "Record_StringDataGet failed, hresult 0x%08x\n", hr);
1597             ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szTwo);
1598
1599             IDispatch_Release(pRecord);
1600         }
1601
1602         /* View::Fetch */
1603         hr = View_Fetch(pView, &pRecord);
1604         ok(hr == S_OK, "View_Fetch failed, hresult 0x%08x\n", hr);
1605         ok(pRecord == NULL, "View_Fetch should have returned NULL record\n");
1606         if (pRecord)
1607             IDispatch_Release(pRecord);
1608
1609         /* View::Close */
1610         hr = View_Close(pView);
1611         ok(hr == S_OK, "View_Close failed, hresult 0x%08x\n", hr);
1612
1613         IDispatch_Release(pView);
1614     }
1615
1616     /* Database::SummaryInformation */
1617     hr = Database_SummaryInformation(pDatabase, TEST_SUMMARYINFO_PROPERTIES_MODIFIED, &pSummaryInfo);
1618     ok(hr == S_OK, "Database_SummaryInformation failed, hresult 0x%08x\n", hr);
1619     ok(pSummaryInfo != NULL, "Database_SummaryInformation should not have returned NULL record\n");
1620     if (pSummaryInfo)
1621     {
1622         test_SummaryInfo(pSummaryInfo, summary_info, sizeof(summary_info)/sizeof(msi_summary_info), readonly);
1623         IDispatch_Release(pSummaryInfo);
1624     }
1625 }
1626
1627 static void test_Session(IDispatch *pSession)
1628 {
1629     static WCHAR szProductName[] = { 'P','r','o','d','u','c','t','N','a','m','e',0 };
1630     static WCHAR szOne[] = { 'O','n','e',0 };
1631     static WCHAR szOneStateFalse[] = { '!','O','n','e','>','0',0 };
1632     static WCHAR szOneStateTrue[] = { '!','O','n','e','=','-','1',0 };
1633     static WCHAR szOneActionFalse[] = { '$','O','n','e','=','-','1',0 };
1634     static WCHAR szOneActionTrue[] = { '$','O','n','e','>','0',0 };
1635     static WCHAR szCostInitialize[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
1636     static WCHAR szEmpty[] = { 0 };
1637     static WCHAR szEquals[] = { '=',0 };
1638     static WCHAR szPropertyName[] = { 'P','r','o','p','e','r','t','y',',','N','a','m','e',0 };
1639     WCHAR stringw[MAX_PATH];
1640     CHAR string[MAX_PATH];
1641     UINT len;
1642     BOOL bool;
1643     int myint;
1644     IDispatch *pDatabase = NULL, *pInst = NULL, *record = NULL;
1645     HRESULT hr;
1646
1647     /* Session::Installer */
1648     hr = Session_Installer(pSession, &pInst);
1649     ok(hr == S_OK, "Session_Installer failed, hresult 0x%08x\n", hr);
1650     ok(pInst != NULL, "Session_Installer returned NULL IDispatch pointer\n");
1651     ok(pInst == pInstaller, "Session_Installer does not match Installer instance from CoCreateInstance\n");
1652
1653     /* Session::Property, get */
1654     memset(stringw, 0, sizeof(stringw));
1655     hr = Session_PropertyGet(pSession, szProductName, stringw);
1656     ok(hr == S_OK, "Session_PropertyGet failed, hresult 0x%08x\n", hr);
1657     if (lstrcmpW(stringw, szMSITEST) != 0)
1658     {
1659         len = WideCharToMultiByte(CP_ACP, 0, stringw, -1, string, MAX_PATH, NULL, NULL);
1660         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError());
1661         ok(0, "Property \"ProductName\" expected to be \"MSITEST\" but was \"%s\"\n", string);
1662     }
1663
1664     /* Session::Property, put */
1665     hr = Session_PropertyPut(pSession, szProductName, szProductName);
1666     ok(hr == S_OK, "Session_PropertyPut failed, hresult 0x%08x\n", hr);
1667     memset(stringw, 0, sizeof(stringw));
1668     hr = Session_PropertyGet(pSession, szProductName, stringw);
1669     ok(hr == S_OK, "Session_PropertyGet failed, hresult 0x%08x\n", hr);
1670     if (lstrcmpW(stringw, szProductName) != 0)
1671     {
1672         len = WideCharToMultiByte(CP_ACP, 0, stringw, -1, string, MAX_PATH, NULL, NULL);
1673         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError());
1674         ok(0, "Property \"ProductName\" expected to be \"ProductName\" but was \"%s\"\n", string);
1675     }
1676
1677     /* Try putting a property using empty property identifier */
1678     hr = Session_PropertyPut(pSession, szEmpty, szProductName);
1679     ok(hr == DISP_E_EXCEPTION, "Session_PropertyPut failed, hresult 0x%08x\n", hr);
1680     ok_exception(hr, szPropertyName);
1681
1682     /* Try putting a property using illegal property identifier */
1683     hr = Session_PropertyPut(pSession, szEquals, szProductName);
1684     ok(hr == S_OK, "Session_PropertyPut failed, hresult 0x%08x\n", hr);
1685
1686     /* Session::Language, get */
1687     hr = Session_LanguageGet(pSession, &len);
1688     ok(hr == S_OK, "Session_LanguageGet failed, hresult 0x%08x\n", hr);
1689     /* Not sure how to check the language is correct */
1690
1691     /* Session::Mode, get */
1692     hr = Session_ModeGet(pSession, MSIRUNMODE_REBOOTATEND, &bool);
1693     ok(hr == S_OK, "Session_ModeGet failed, hresult 0x%08x\n", hr);
1694     todo_wine ok(!bool, "Reboot at end session mode is %d\n", bool);
1695
1696     /* Session::Mode, put */
1697     hr = Session_ModePut(pSession, MSIRUNMODE_REBOOTATEND, TRUE);
1698     todo_wine ok(hr == S_OK, "Session_ModePut failed, hresult 0x%08x\n", hr);
1699     hr = Session_ModeGet(pSession, MSIRUNMODE_REBOOTATEND, &bool);
1700     ok(hr == S_OK, "Session_ModeGet failed, hresult 0x%08x\n", hr);
1701     ok(bool, "Reboot at end session mode is %d, expected 1\n", bool);
1702     hr = Session_ModePut(pSession, MSIRUNMODE_REBOOTATEND, FALSE);  /* set it again so we don't reboot */
1703     todo_wine ok(hr == S_OK, "Session_ModePut failed, hresult 0x%08x\n", hr);
1704
1705     /* Session::Database, get */
1706     hr = Session_Database(pSession, &pDatabase);
1707     ok(hr == S_OK, "Session_Database failed, hresult 0x%08x\n", hr);
1708     if (hr == S_OK)
1709     {
1710         test_Database(pDatabase, TRUE);
1711         IDispatch_Release(pDatabase);
1712     }
1713
1714     /* Session::EvaluateCondition */
1715     hr = Session_EvaluateCondition(pSession, NULL, &myint);
1716     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1717     ok(myint == MSICONDITION_NONE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1718
1719     hr = Session_EvaluateCondition(pSession, szEmpty, &myint);
1720     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1721     ok(myint == MSICONDITION_NONE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1722
1723     hr = Session_EvaluateCondition(pSession, szEquals, &myint);
1724     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1725     ok(myint == MSICONDITION_ERROR, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1726
1727     /* Session::DoAction(CostInitialize) must occur before the next statements */
1728     hr = Session_DoAction(pSession, szCostInitialize, &myint);
1729     ok(hr == S_OK, "Session_DoAction failed, hresult 0x%08x\n", hr);
1730     ok(myint == IDOK, "DoAction(CostInitialize) returned %d, %d expected\n", myint, IDOK);
1731
1732     /* Session::SetInstallLevel */
1733     hr = Session_SetInstallLevel(pSession, INSTALLLEVEL_MINIMUM);
1734     ok(hr == S_OK, "Session_SetInstallLevel failed, hresult 0x%08x\n", hr);
1735
1736     /* Session::FeatureCurrentState, get */
1737     hr = Session_FeatureCurrentState(pSession, szOne, &myint);
1738     ok(hr == S_OK, "Session_FeatureCurrentState failed, hresult 0x%08x\n", hr);
1739     ok(myint == INSTALLSTATE_UNKNOWN, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1740
1741     /* Session::Message */
1742     hr = Installer_CreateRecord(0, &record);
1743     ok(hr == S_OK, "Installer_CreateRecord failed: %08x\n", hr);
1744     hr = Session_Message(pSession, INSTALLMESSAGE_INFO, record, &myint);
1745     ok(hr == S_OK, "Session_Message failed: %08x\n", hr);
1746     ok(myint == 0, "Session_Message returned %x\n", myint);
1747
1748     /* Session::EvaluateCondition */
1749     hr = Session_EvaluateCondition(pSession, szOneStateFalse, &myint);
1750     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1751     ok(myint == MSICONDITION_FALSE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1752
1753     hr = Session_EvaluateCondition(pSession, szOneStateTrue, &myint);
1754     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1755     ok(myint == MSICONDITION_TRUE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1756
1757     /* Session::FeatureRequestState, put */
1758     hr = Session_FeatureRequestStatePut(pSession, szOne, INSTALLSTATE_ADVERTISED);
1759     ok(hr == S_OK, "Session_FeatureRequestStatePut failed, hresult 0x%08x\n", hr);
1760     hr = Session_FeatureRequestStateGet(pSession, szOne, &myint);
1761     ok(hr == S_OK, "Session_FeatureRequestStateGet failed, hresult 0x%08x\n", hr);
1762     ok(myint == INSTALLSTATE_ADVERTISED, "Feature request state was %d but expected %d\n", myint, INSTALLSTATE_ADVERTISED);
1763
1764     /* Session::EvaluateCondition */
1765     hr = Session_EvaluateCondition(pSession, szOneActionFalse, &myint);
1766     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1767     ok(myint == MSICONDITION_FALSE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1768
1769     hr = Session_EvaluateCondition(pSession, szOneActionTrue, &myint);
1770     ok(hr == S_OK, "Session_EvaluateCondition failed, hresult 0x%08x\n", hr);
1771     ok(myint == MSICONDITION_TRUE, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
1772 }
1773
1774 /* delete key and all its subkeys */
1775 static DWORD delete_key( HKEY hkey )
1776 {
1777     char name[MAX_PATH];
1778     DWORD ret;
1779
1780     while (!(ret = RegEnumKeyA(hkey, 0, name, sizeof(name))))
1781     {
1782         HKEY tmp;
1783         if (!(ret = RegOpenKeyExA( hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp )))
1784         {
1785             ret = delete_key( tmp );
1786             RegCloseKey( tmp );
1787         }
1788         if (ret) break;
1789     }
1790     if (ret != ERROR_NO_MORE_ITEMS) return ret;
1791     RegDeleteKeyA( hkey, "" );
1792     return 0;
1793 }
1794
1795 static void test_Installer_RegistryValue(void)
1796 {
1797     static const DWORD qw[2] = { 0x12345678, 0x87654321 };
1798     static const WCHAR szKey[] = { 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t',0 };
1799     static const WCHAR szOne[] = { 'O','n','e',0 };
1800     static const WCHAR szTwo[] = { 'T','w','o',0 };
1801     static const WCHAR szThree[] = { 'T','h','r','e','e',0 };
1802     static const WCHAR szREG_BINARY[] = { '(','R','E','G','_','B','I','N','A','R','Y',')',0 };
1803     static const WCHAR szFour[] = { 'F','o','u','r',0 };
1804     static const WCHAR szExpand[] = { '%','M','S','I','T','E','S','T','%',0 };
1805     static const WCHAR szFive[] = { 'F','i','v','e',0,'H','i',0,0 };
1806     static const WCHAR szFiveHi[] = { 'F','i','v','e','\n','H','i',0 };
1807     static const WCHAR szSix[] = { 'S','i','x',0 };
1808     static const WCHAR szREG_[] = { '(','R','E','G','_',']',0 };
1809     static const WCHAR szSeven[] = { 'S','e','v','e','n',0 };
1810     static const WCHAR szEight[] = { 'E','i','g','h','t',0 };
1811     static const WCHAR szBlank[] = { 0 };
1812     VARIANT varresult;
1813     VARIANTARG vararg;
1814     WCHAR szString[MAX_PATH];
1815     HKEY hkey, hkey_sub;
1816     HKEY curr_user = (HKEY)1;
1817     HRESULT hr;
1818     BOOL bRet;
1819     LONG lRet;
1820
1821     /* Delete keys */
1822     SetLastError(0xdeadbeef);
1823     lRet = RegOpenKeyW( HKEY_CURRENT_USER, szKey, &hkey );
1824     if (!lRet && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1825     {
1826         win_skip("Needed W-functions are not implemented\n");
1827         return;
1828     }
1829     if (!lRet)
1830         delete_key( hkey );
1831
1832     /* Does our key exist? Shouldn't; check with all three possible value parameter types */
1833     hr = Installer_RegistryValueE(curr_user, szKey, &bRet);
1834     ok(hr == S_OK, "Installer_RegistryValueE failed, hresult 0x%08x\n", hr);
1835     ok(!bRet, "Registry key expected to not exist, but Installer_RegistryValue claims it does\n");
1836
1837     memset(szString, 0, sizeof(szString));
1838     hr = Installer_RegistryValueW(curr_user, szKey, NULL, szString);
1839     ok(hr == DISP_E_BADINDEX, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1840
1841     memset(szString, 0, sizeof(szString));
1842     hr = Installer_RegistryValueI(curr_user, szKey, 0, szString, VT_BSTR);
1843     ok(hr == DISP_E_BADINDEX, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1844
1845     /* Create key */
1846     ok(!RegCreateKeyW( HKEY_CURRENT_USER, szKey, &hkey ), "RegCreateKeyW failed\n");
1847
1848     ok(!RegSetValueExW(hkey,szOne,0,REG_SZ, (const BYTE *)szOne, sizeof(szOne)),
1849         "RegSetValueExW failed\n");
1850     ok(!RegSetValueExW(hkey,szTwo,0,REG_DWORD, (const BYTE *)qw, 4),
1851         "RegSetValueExW failed\n");
1852     ok(!RegSetValueExW(hkey,szThree,0,REG_BINARY, (const BYTE *)qw, 4),
1853         "RegSetValueExW failed\n");
1854     ok(SetEnvironmentVariableA("MSITEST", "Four"), "SetEnvironmentVariableA failed %d\n", GetLastError());
1855     ok(!RegSetValueExW(hkey,szFour,0,REG_EXPAND_SZ, (const BYTE *)szExpand, sizeof(szExpand)),
1856         "RegSetValueExW failed\n");
1857     ok(!RegSetValueExW(hkey,szFive,0,REG_MULTI_SZ, (const BYTE *)szFive, sizeof(szFive)),
1858         "RegSetValueExW failed\n");
1859     ok(!RegSetValueExW(hkey,szSix,0,REG_QWORD, (const BYTE *)qw, 8),
1860         "RegSetValueExW failed\n");
1861     ok(!RegSetValueExW(hkey,szSeven,0,REG_NONE, NULL, 0),
1862         "RegSetValueExW failed\n");
1863
1864     ok(!RegSetValueExW(hkey,NULL,0,REG_SZ, (const BYTE *)szOne, sizeof(szOne)),
1865         "RegSetValueExW failed\n");
1866
1867     ok(!RegCreateKeyW( hkey, szEight, &hkey_sub ), "RegCreateKeyW failed\n");
1868
1869     /* Does our key exist? It should, and make sure we retrieve the correct default value */
1870     bRet = FALSE;
1871     hr = Installer_RegistryValueE(curr_user, szKey, &bRet);
1872     ok(hr == S_OK, "Installer_RegistryValueE failed, hresult 0x%08x\n", hr);
1873     ok(bRet, "Registry key expected to exist, but Installer_RegistryValue claims it does not\n");
1874
1875     memset(szString, 0, sizeof(szString));
1876     hr = Installer_RegistryValueW(curr_user, szKey, NULL, szString);
1877     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1878     ok_w2("Default registry value \"%s\" does not match expected \"%s\"\n", szString, szOne);
1879
1880     /* Ask for the value of a nonexistent key */
1881     memset(szString, 0, sizeof(szString));
1882     hr = Installer_RegistryValueW(curr_user, szKey, szExpand, szString);
1883     ok(hr == DISP_E_BADINDEX, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1884
1885     /* Get values of keys */
1886     memset(szString, 0, sizeof(szString));
1887     hr = Installer_RegistryValueW(curr_user, szKey, szOne, szString);
1888     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1889     ok_w2("Registry value \"%s\" does not match expected \"%s\"\n", szString, szOne);
1890
1891     VariantInit(&vararg);
1892     V_VT(&vararg) = VT_BSTR;
1893     V_BSTR(&vararg) = SysAllocString(szTwo);
1894     hr = Installer_RegistryValue(curr_user, szKey, vararg, &varresult, VT_I4);
1895     ok(hr == S_OK, "Installer_RegistryValue failed, hresult 0x%08x\n", hr);
1896     ok(V_I4(&varresult) == 305419896, "Registry value %d does not match expected value\n", V_I4(&varresult));
1897     VariantClear(&varresult);
1898
1899     memset(szString, 0, sizeof(szString));
1900     hr = Installer_RegistryValueW(curr_user, szKey, szThree, szString);
1901     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1902     ok_w2("Registry value \"%s\" does not match expected \"%s\"\n", szString, szREG_BINARY);
1903
1904     memset(szString, 0, sizeof(szString));
1905     hr = Installer_RegistryValueW(curr_user, szKey, szFour, szString);
1906     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1907     ok_w2("Registry value \"%s\" does not match expected \"%s\"\n", szString, szFour);
1908
1909     /* Vista does not NULL-terminate this case */
1910     memset(szString, 0, sizeof(szString));
1911     hr = Installer_RegistryValueW(curr_user, szKey, szFive, szString);
1912     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1913     ok_w2n("Registry value \"%s\" does not match expected \"%s\"\n",
1914            szString, szFiveHi, lstrlenW(szFiveHi));
1915
1916     memset(szString, 0, sizeof(szString));
1917     hr = Installer_RegistryValueW(curr_user, szKey, szSix, szString);
1918     ok(hr == S_OK, "Installer_RegistryValueW failed, hresult 0x%08x\n", hr);
1919     ok_w2("Registry value \"%s\" does not match expected \"%s\"\n", szString, szREG_);
1920
1921     VariantInit(&vararg);
1922     V_VT(&vararg) = VT_BSTR;
1923     V_BSTR(&vararg) = SysAllocString(szSeven);
1924     hr = Installer_RegistryValue(curr_user, szKey, vararg, &varresult, VT_EMPTY);
1925     ok(hr == S_OK, "Installer_RegistryValue failed, hresult 0x%08x\n", hr);
1926
1927     /* Get string class name for the key */
1928     memset(szString, 0, sizeof(szString));
1929     hr = Installer_RegistryValueI(curr_user, szKey, 0, szString, VT_BSTR);
1930     ok(hr == S_OK, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1931     ok_w2("Registry name \"%s\" does not match expected \"%s\"\n", szString, szBlank);
1932
1933     /* Get name of a value by positive number (RegEnumValue like), valid index */
1934     memset(szString, 0, sizeof(szString));
1935     hr = Installer_RegistryValueI(curr_user, szKey, 2, szString, VT_BSTR);
1936     ok(hr == S_OK, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1937     /* RegEnumValue order seems different on wine */
1938     todo_wine ok_w2("Registry name \"%s\" does not match expected \"%s\"\n", szString, szTwo);
1939
1940     /* Get name of a value by positive number (RegEnumValue like), invalid index */
1941     memset(szString, 0, sizeof(szString));
1942     hr = Installer_RegistryValueI(curr_user, szKey, 10, szString, VT_EMPTY);
1943     ok(hr == S_OK, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1944
1945     /* Get name of a subkey by negative number (RegEnumValue like), valid index */
1946     memset(szString, 0, sizeof(szString));
1947     hr = Installer_RegistryValueI(curr_user, szKey, -1, szString, VT_BSTR);
1948     ok(hr == S_OK, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1949     ok_w2("Registry name \"%s\" does not match expected \"%s\"\n", szString, szEight);
1950
1951     /* Get name of a subkey by negative number (RegEnumValue like), invalid index */
1952     memset(szString, 0, sizeof(szString));
1953     hr = Installer_RegistryValueI(curr_user, szKey, -10, szString, VT_EMPTY);
1954     ok(hr == S_OK, "Installer_RegistryValueI failed, hresult 0x%08x\n", hr);
1955
1956     /* clean up */
1957     delete_key(hkey);
1958 }
1959
1960 static void test_Installer_Products(BOOL bProductInstalled)
1961 {
1962     WCHAR szString[MAX_PATH];
1963     HRESULT hr;
1964     int idx;
1965     IUnknown *pUnk = NULL;
1966     IEnumVARIANT *pEnum = NULL;
1967     VARIANT var;
1968     ULONG celt;
1969     int iCount, iValue;
1970     IDispatch *pStringList = NULL;
1971     BOOL bProductFound = FALSE;
1972
1973     /* Installer::Products */
1974     hr = Installer_Products(&pStringList);
1975     ok(hr == S_OK, "Installer_Products failed, hresult 0x%08x\n", hr);
1976     if (hr == S_OK)
1977     {
1978         /* StringList::_NewEnum */
1979         hr = StringList__NewEnum(pStringList, &pUnk);
1980         ok(hr == S_OK, "StringList_NewEnum failed, hresult 0x%08x\n", hr);
1981         if (hr == S_OK)
1982         {
1983             hr = IUnknown_QueryInterface(pUnk, &IID_IEnumVARIANT, (void **)&pEnum);
1984             ok (hr == S_OK, "IUnknown::QueryInterface returned 0x%08x\n", hr);
1985         }
1986         if (!pEnum)
1987             skip("IEnumVARIANT tests\n");
1988
1989         /* StringList::Count */
1990         hr = StringList_Count(pStringList, &iCount);
1991         ok(hr == S_OK, "StringList_Count failed, hresult 0x%08x\n", hr);
1992
1993         for (idx=0; idx<iCount; idx++)
1994         {
1995             /* StringList::Item */
1996             memset(szString, 0, sizeof(szString));
1997             hr = StringList_Item(pStringList, idx, szString);
1998             ok(hr == S_OK, "StringList_Item failed (idx %d, count %d), hresult 0x%08x\n", idx, iCount, hr);
1999
2000             if (hr == S_OK)
2001             {
2002                 /* Installer::ProductState */
2003                 hr = Installer_ProductState(szString, &iValue);
2004                 ok(hr == S_OK, "Installer_ProductState failed, hresult 0x%08x\n", hr);
2005                 if (hr == S_OK)
2006                     ok(iValue == INSTALLSTATE_DEFAULT || iValue == INSTALLSTATE_ADVERTISED, "Installer_ProductState returned %d, expected %d or %d\n", iValue, INSTALLSTATE_DEFAULT, INSTALLSTATE_ADVERTISED);
2007
2008                 /* Not found our product code yet? Check */
2009                 if (!bProductFound && !lstrcmpW(szString, szProductCode))
2010                     bProductFound = TRUE;
2011
2012                 /* IEnumVARIANT::Next */
2013                 if (pEnum)
2014                 {
2015                     hr = IEnumVARIANT_Next(pEnum, 1, &var, &celt);
2016                     ok(hr == S_OK, "IEnumVARIANT_Next failed (idx %d, count %d), hresult 0x%08x\n", idx, iCount, hr);
2017                     ok(celt == 1, "%d items were retrieved, expected 1\n", celt);
2018                     ok(V_VT(&var) == VT_BSTR, "IEnumVARIANT_Next returned variant of type %d, expected %d\n", V_VT(&var), VT_BSTR);
2019                     ok_w2("%s returned by StringList_Item does not match %s returned by IEnumVARIANT_Next\n", szString, V_BSTR(&var));
2020                     VariantClear(&var);
2021                 }
2022             }
2023         }
2024
2025         if (bProductInstalled) todo_wine
2026         {
2027             ok(bProductInstalled == bProductFound, "Product expected to %s installed but product code was %s\n",
2028                bProductInstalled ? "be" : "not be",
2029                bProductFound ? "found" : "not found");
2030         }
2031
2032         if (pEnum)
2033         {
2034             IEnumVARIANT *pEnum2 = NULL;
2035
2036             if (0) /* Crashes on Windows XP */
2037             {
2038                 /* IEnumVARIANT::Clone, NULL pointer */
2039                 hr = IEnumVARIANT_Clone(pEnum, NULL);
2040             }
2041
2042             /* IEnumVARIANT::Clone */
2043             hr = IEnumVARIANT_Clone(pEnum, &pEnum2);
2044             ok(hr == S_OK, "IEnumVARIANT_Clone failed, hresult 0x%08x\n", hr);
2045             if (hr == S_OK)
2046             {
2047                 /* IEnumVARIANT::Clone is supposed to save the position, but it actually just goes back to the beginning */
2048
2049                 /* IEnumVARIANT::Next of the clone */
2050                 if (iCount)
2051                 {
2052                     hr = IEnumVARIANT_Next(pEnum2, 1, &var, &celt);
2053                     ok(hr == S_OK, "IEnumVARIANT_Next failed, hresult 0x%08x\n", hr);
2054                     ok(celt == 1, "%d items were retrieved, expected 0\n", celt);
2055                     ok(V_VT(&var) == VT_BSTR, "IEnumVARIANT_Next returned variant of type %d, expected %d\n", V_VT(&var), VT_BSTR);
2056                     VariantClear(&var);
2057                 }
2058                 else
2059                     skip("IEnumVARIANT::Next of clone will not return success with 0 products\n");
2060
2061                 IEnumVARIANT_Release(pEnum2);
2062             }
2063
2064             /* IEnumVARIANT::Skip should fail */
2065             hr = IEnumVARIANT_Skip(pEnum, 1);
2066             ok(hr == S_FALSE, "IEnumVARIANT_Skip failed, hresult 0x%08x\n", hr);
2067
2068             /* IEnumVARIANT::Next, NULL variant pointer */
2069             hr = IEnumVARIANT_Next(pEnum, 1, NULL, &celt);
2070             ok(hr == S_FALSE, "IEnumVARIANT_Next failed, hresult 0x%08x\n", hr);
2071             ok(celt == 0, "%d items were retrieved, expected 0\n", celt);
2072
2073             /* IEnumVARIANT::Next, should not return any more items */
2074             hr = IEnumVARIANT_Next(pEnum, 1, &var, &celt);
2075             ok(hr == S_FALSE, "IEnumVARIANT_Next failed, hresult 0x%08x\n", hr);
2076             ok(celt == 0, "%d items were retrieved, expected 0\n", celt);
2077             VariantClear(&var);
2078
2079             /* IEnumVARIANT::Reset */
2080             hr = IEnumVARIANT_Reset(pEnum);
2081             ok(hr == S_OK, "IEnumVARIANT_Reset failed, hresult 0x%08x\n", hr);
2082
2083             if (iCount)
2084             {
2085                 /* IEnumVARIANT::Skip to the last product */
2086                 hr = IEnumVARIANT_Skip(pEnum, iCount-1);
2087                 ok(hr == S_OK, "IEnumVARIANT_Skip failed, hresult 0x%08x\n", hr);
2088
2089                 /* IEnumVARIANT::Next should match the very last retrieved value, also makes sure it works with
2090                  * NULL celt pointer. */
2091                 hr = IEnumVARIANT_Next(pEnum, 1, &var, NULL);
2092                 ok(hr == S_OK, "IEnumVARIANT_Next failed (idx %d, count %d), hresult 0x%08x\n", idx, iCount, hr);
2093                 ok(V_VT(&var) == VT_BSTR, "IEnumVARIANT_Next returned variant of type %d, expected %d\n", V_VT(&var), VT_BSTR);
2094                 ok_w2("%s returned by StringList_Item does not match %s returned by IEnumVARIANT_Next\n", szString, V_BSTR(&var));
2095                 VariantClear(&var);
2096             }
2097             else
2098                 skip("IEnumVARIANT::Skip impossible for 0 products\n");
2099         }
2100
2101         /* StringList::Item using an invalid index */
2102         memset(szString, 0, sizeof(szString));
2103         hr = StringList_Item(pStringList, iCount, szString);
2104         ok(hr == DISP_E_BADINDEX, "StringList_Item for an invalid index did not return DISP_E_BADINDEX, hresult 0x%08x\n", hr);
2105
2106         if (pEnum) IEnumVARIANT_Release(pEnum);
2107         if (pUnk) IUnknown_Release(pUnk);
2108         IDispatch_Release(pStringList);
2109     }
2110 }
2111
2112 /* Delete a registry subkey, including all its subkeys (RegDeleteKey does not work on keys with subkeys without
2113  * deleting the subkeys first) */
2114 static UINT delete_registry_key(HKEY hkeyParent, LPCSTR subkey)
2115 {
2116     UINT ret;
2117     CHAR *string = NULL;
2118     HKEY hkey;
2119     DWORD dwSize;
2120
2121     ret = RegOpenKey(hkeyParent, subkey, &hkey);
2122     if (ret != ERROR_SUCCESS) return ret;
2123     ret = RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, &dwSize, NULL, NULL, NULL, NULL, NULL, NULL);
2124     if (ret != ERROR_SUCCESS) return ret;
2125     if (!(string = HeapAlloc(GetProcessHeap(), 0, ++dwSize))) return ERROR_NOT_ENOUGH_MEMORY;
2126
2127     while (RegEnumKeyA(hkey, 0, string, dwSize) == ERROR_SUCCESS)
2128         delete_registry_key(hkey, string);
2129
2130     RegCloseKey(hkey);
2131     HeapFree(GetProcessHeap(), 0, string);
2132     RegDeleteKeyA(hkeyParent, subkey);
2133     return ERROR_SUCCESS;
2134 }
2135
2136 /* Find a specific registry subkey at any depth within the given key and subkey and return its parent key. */
2137 static UINT find_registry_key(HKEY hkeyParent, LPCSTR subkey, LPCSTR findkey, HKEY *phkey)
2138 {
2139     UINT ret;
2140     CHAR *string = NULL;
2141     int idx = 0;
2142     HKEY hkey;
2143     DWORD dwSize;
2144     BOOL found = FALSE;
2145
2146     *phkey = 0;
2147
2148     ret = RegOpenKey(hkeyParent, subkey, &hkey);
2149     if (ret != ERROR_SUCCESS) return ret;
2150     ret = RegQueryInfoKeyA(hkey, NULL, NULL, NULL, NULL, &dwSize, NULL, NULL, NULL, NULL, NULL, NULL);
2151     if (ret != ERROR_SUCCESS) return ret;
2152     if (!(string = HeapAlloc(GetProcessHeap(), 0, ++dwSize))) return ERROR_NOT_ENOUGH_MEMORY;
2153
2154     while (!found &&
2155            RegEnumKeyA(hkey, idx++, string, dwSize) == ERROR_SUCCESS)
2156     {
2157         if (!strcmp(string, findkey))
2158         {
2159             *phkey = hkey;
2160             found = TRUE;
2161         }
2162         else if (find_registry_key(hkey, string, findkey, phkey) == ERROR_SUCCESS) found = TRUE;
2163     }
2164
2165     if (*phkey != hkey) RegCloseKey(hkey);
2166     HeapFree(GetProcessHeap(), 0, string);
2167     return (found ? ERROR_SUCCESS : ERROR_FILE_NOT_FOUND);
2168 }
2169
2170 static void test_Installer_InstallProduct(void)
2171 {
2172     HRESULT hr;
2173     CHAR path[MAX_PATH];
2174     WCHAR szString[MAX_PATH];
2175     LONG res;
2176     HKEY hkey;
2177     DWORD num, size, type;
2178     int iValue, iCount;
2179     IDispatch *pStringList = NULL;
2180
2181     create_test_files();
2182
2183     /* Installer::InstallProduct */
2184     hr = Installer_InstallProduct(szMsifile, NULL);
2185     if (hr == DISP_E_EXCEPTION)
2186     {
2187         skip("Installer object not supported.\n");
2188         delete_test_files();
2189         return;
2190     }
2191     ok(hr == S_OK, "Installer_InstallProduct failed, hresult 0x%08x\n", hr);
2192
2193     /* Installer::ProductState for our product code, which has been installed */
2194     hr = Installer_ProductState(szProductCode, &iValue);
2195     ok(hr == S_OK, "Installer_ProductState failed, hresult 0x%08x\n", hr);
2196     ok(iValue == INSTALLSTATE_DEFAULT, "Installer_ProductState returned %d, expected %d\n", iValue, INSTALLSTATE_DEFAULT);
2197
2198     /* Installer::ProductInfo for our product code */
2199
2200     /* NULL attribute */
2201     memset(szString, 0, sizeof(szString));
2202     hr = Installer_ProductInfo(szProductCode, NULL, szString);
2203     ok(hr == DISP_E_EXCEPTION, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2204     ok_exception(hr, szProductInfoException);
2205
2206     /* Nonexistent attribute */
2207     memset(szString, 0, sizeof(szString));
2208     hr = Installer_ProductInfo(szProductCode, szMsifile, szString);
2209     ok(hr == DISP_E_EXCEPTION, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2210     ok_exception(hr, szProductInfoException);
2211
2212     /* Package name */
2213     memset(szString, 0, sizeof(szString));
2214     hr = Installer_ProductInfo(szProductCode, WINE_INSTALLPROPERTY_PACKAGENAMEW, szString);
2215     ok(hr == S_OK, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2216     todo_wine ok_w2("Installer_ProductInfo returned %s but expected %s\n", szString, szMsifile);
2217
2218     /* Product name */
2219     memset(szString, 0, sizeof(szString));
2220     hr = Installer_ProductInfo(szProductCode, WINE_INSTALLPROPERTY_PRODUCTNAMEW, szString);
2221     ok(hr == S_OK, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2222     todo_wine ok_w2("Installer_ProductInfo returned %s but expected %s\n", szString, szMSITEST);
2223
2224     /* Installer::Products */
2225     test_Installer_Products(TRUE);
2226
2227     /* Installer::RelatedProducts for our upgrade code */
2228     hr = Installer_RelatedProducts(szUpgradeCode, &pStringList);
2229     ok(hr == S_OK, "Installer_RelatedProducts failed, hresult 0x%08x\n", hr);
2230     if (hr == S_OK)
2231     {
2232         /* StringList::Count */
2233         hr = StringList_Count(pStringList, &iCount);
2234         ok(hr == S_OK, "StringList_Count failed, hresult 0x%08x\n", hr);
2235         ok(iCount == 1, "Expected one related product but found %d\n", iCount);
2236
2237         /* StringList::Item */
2238         memset(szString, 0, sizeof(szString));
2239         hr = StringList_Item(pStringList, 0, szString);
2240         ok(hr == S_OK, "StringList_Item failed (idx 0, count %d), hresult 0x%08x\n", iCount, hr);
2241         ok_w2("StringList_Item returned %s but expected %s\n", szString, szProductCode);
2242
2243         IDispatch_Release(pStringList);
2244     }
2245
2246     /* Check & clean up installed files & registry keys */
2247     ok(delete_pf("msitest\\cabout\\new\\five.txt", TRUE), "File not installed\n");
2248     ok(delete_pf("msitest\\cabout\\new", FALSE), "File not installed\n");
2249     ok(delete_pf("msitest\\cabout\\four.txt", TRUE), "File not installed\n");
2250     ok(delete_pf("msitest\\cabout", FALSE), "File not installed\n");
2251     ok(delete_pf("msitest\\changed\\three.txt", TRUE), "File not installed\n");
2252     ok(delete_pf("msitest\\changed", FALSE), "File not installed\n");
2253     ok(delete_pf("msitest\\first\\two.txt", TRUE), "File not installed\n");
2254     ok(delete_pf("msitest\\first", FALSE), "File not installed\n");
2255     ok(delete_pf("msitest\\one.txt", TRUE), "File not installed\n");
2256     ok(delete_pf("msitest\\filename", TRUE), "File not installed\n");
2257     ok(delete_pf("msitest", FALSE), "File not installed\n");
2258
2259     res = RegOpenKey(HKEY_LOCAL_MACHINE, "SOFTWARE\\Wine\\msitest", &hkey);
2260     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2261
2262     size = MAX_PATH;
2263     type = REG_SZ;
2264     res = RegQueryValueExA(hkey, "Name", NULL, &type, (LPBYTE)path, &size);
2265     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2266     ok(!lstrcmpA(path, "imaname"), "Expected imaname, got %s\n", path);
2267
2268     size = MAX_PATH;
2269     type = REG_SZ;
2270     res = RegQueryValueExA(hkey, "blah", NULL, &type, (LPBYTE)path, &size);
2271     ok(res == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", res);
2272
2273     size = sizeof(num);
2274     type = REG_DWORD;
2275     res = RegQueryValueExA(hkey, "number", NULL, &type, (LPBYTE)&num, &size);
2276     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2277     ok(num == 314, "Expected 314, got %d\n", num);
2278
2279     size = MAX_PATH;
2280     type = REG_SZ;
2281     res = RegQueryValueExA(hkey, "OrderTestName", NULL, &type, (LPBYTE)path, &size);
2282     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2283     ok(!lstrcmpA(path, "OrderTestValue"), "Expected imaname, got %s\n", path);
2284
2285     RegCloseKey(hkey);
2286
2287     res = RegDeleteKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Wine\\msitest");
2288     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2289
2290     /* Remove registry keys written by RegisterProduct standard action */
2291     res = RegDeleteKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{F1C3AF50-8B56-4A69-A00C-00773FE42F30}");
2292     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2293
2294     res = RegDeleteKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UpgradeCodes\\D8E760ECA1E276347B43E42BDBDA5656");
2295     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2296
2297     res = find_registry_key(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData", "05FA3C1F65B896A40AC00077F34EF203", &hkey);
2298     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2299     if (res == ERROR_SUCCESS)
2300     {
2301         res = delete_registry_key(hkey, "05FA3C1F65B896A40AC00077F34EF203");
2302         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2303         RegCloseKey(hkey);
2304     }
2305
2306     /* Remove registry keys written by PublishProduct standard action */
2307     res = RegOpenKey(HKEY_CURRENT_USER, "SOFTWARE\\Microsoft\\Installer", &hkey);
2308     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2309
2310     res = delete_registry_key(hkey, "Products\\05FA3C1F65B896A40AC00077F34EF203");
2311     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2312
2313     res = RegDeleteKeyA(hkey, "UpgradeCodes\\D8E760ECA1E276347B43E42BDBDA5656");
2314     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
2315
2316     RegCloseKey(hkey);
2317
2318     res = RegDeleteKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\Products\\05FA3C1F65B896A40AC00077F34EF203");
2319     ok(res == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", res);
2320
2321     /* Delete installation files we installed */
2322     delete_test_files();
2323 }
2324
2325 static void test_Installer(void)
2326 {
2327     static WCHAR szBackslash[] = { '\\',0 };
2328     static WCHAR szCreateRecordException[] = { 'C','r','e','a','t','e','R','e','c','o','r','d',',','C','o','u','n','t',0 };
2329     static WCHAR szIntegerDataException[] = { 'I','n','t','e','g','e','r','D','a','t','a',',','F','i','e','l','d',0 };
2330     WCHAR szPath[MAX_PATH];
2331     HRESULT hr;
2332     UINT len;
2333     IDispatch *pSession = NULL, *pDatabase = NULL, *pRecord = NULL, *pStringList = NULL;
2334     int iValue, iCount;
2335
2336     if (!pInstaller) return;
2337
2338     /* Installer::CreateRecord */
2339
2340     /* Test for error */
2341     hr = Installer_CreateRecord(-1, &pRecord);
2342     ok(hr == DISP_E_EXCEPTION, "Installer_CreateRecord failed, hresult 0x%08x\n", hr);
2343     ok_exception(hr, szCreateRecordException);
2344
2345     /* Test for success */
2346     hr = Installer_CreateRecord(1, &pRecord);
2347     ok(hr == S_OK, "Installer_CreateRecord failed, hresult 0x%08x\n", hr);
2348     ok(pRecord != NULL, "Installer_CreateRecord should not have returned NULL record\n");
2349     if (pRecord)
2350     {
2351         /* Record::FieldCountGet */
2352         hr = Record_FieldCountGet(pRecord, &iValue);
2353         ok(hr == S_OK, "Record_FiledCountGet failed, hresult 0x%08x\n", hr);
2354         ok(iValue == 1, "Record_FieldCountGet result was %d but expected 1\n", iValue);
2355
2356         /* Record::IntegerDataGet */
2357         hr = Record_IntegerDataGet(pRecord, 1, &iValue);
2358         ok(hr == S_OK, "Record_IntegerDataGet failed, hresult 0x%08x\n", hr);
2359         ok(iValue == MSI_NULL_INTEGER, "Record_IntegerDataGet result was %d but expected %d\n", iValue, MSI_NULL_INTEGER);
2360
2361         /* Record::IntegerDataGet, bad index */
2362         hr = Record_IntegerDataGet(pRecord, 10, &iValue);
2363         ok(hr == S_OK, "Record_IntegerDataGet failed, hresult 0x%08x\n", hr);
2364         ok(iValue == MSI_NULL_INTEGER, "Record_IntegerDataGet result was %d but expected %d\n", iValue, MSI_NULL_INTEGER);
2365
2366         /* Record::IntegerDataPut */
2367         hr = Record_IntegerDataPut(pRecord, 1, 100);
2368         ok(hr == S_OK, "Record_IntegerDataPut failed, hresult 0x%08x\n", hr);
2369
2370         /* Record::IntegerDataPut, bad index */
2371         hr = Record_IntegerDataPut(pRecord, 10, 100);
2372         ok(hr == DISP_E_EXCEPTION, "Record_IntegerDataPut failed, hresult 0x%08x\n", hr);
2373         ok_exception(hr, szIntegerDataException);
2374
2375         /* Record::IntegerDataGet */
2376         hr = Record_IntegerDataGet(pRecord, 1, &iValue);
2377         ok(hr == S_OK, "Record_IntegerDataGet failed, hresult 0x%08x\n", hr);
2378         ok(iValue == 100, "Record_IntegerDataGet result was %d but expected 100\n", iValue);
2379
2380         IDispatch_Release(pRecord);
2381     }
2382
2383     /* Prepare package */
2384     create_database(msifile, tables, sizeof(tables) / sizeof(msi_table),
2385                     summary_info, sizeof(summary_info) / sizeof(msi_summary_info));
2386
2387     len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, CURR_DIR, -1, szPath, MAX_PATH);
2388     ok(len, "MultiByteToWideChar returned error %d\n", GetLastError());
2389     if (!len) return;
2390
2391     lstrcatW(szPath, szBackslash);
2392     lstrcatW(szPath, szMsifile);
2393
2394     /* Installer::OpenPackage */
2395     hr = Installer_OpenPackage(szPath, 0, &pSession);
2396     ok(hr == S_OK, "Installer_OpenPackage failed, hresult 0x%08x\n", hr);
2397     if (hr == S_OK)
2398     {
2399         test_Session(pSession);
2400         IDispatch_Release(pSession);
2401     }
2402
2403     /* Installer::OpenDatabase */
2404     hr = Installer_OpenDatabase(szPath, (INT_PTR)MSIDBOPEN_TRANSACT, &pDatabase);
2405     ok(hr == S_OK, "Installer_OpenDatabase failed, hresult 0x%08x\n", hr);
2406     if (hr == S_OK)
2407     {
2408         test_Database(pDatabase, FALSE);
2409         IDispatch_Release(pDatabase);
2410     }
2411
2412     /* Installer::RegistryValue */
2413     test_Installer_RegistryValue();
2414
2415     /* Installer::ProductState for our product code, which should not be installed */
2416     hr = Installer_ProductState(szProductCode, &iValue);
2417     ok(hr == S_OK, "Installer_ProductState failed, hresult 0x%08x\n", hr);
2418     ok(iValue == INSTALLSTATE_UNKNOWN, "Installer_ProductState returned %d, expected %d\n", iValue, INSTALLSTATE_UNKNOWN);
2419
2420     /* Installer::ProductInfo for our product code, which should not be installed */
2421
2422     /* Package name */
2423     memset(szPath, 0, sizeof(szPath));
2424     hr = Installer_ProductInfo(szProductCode, WINE_INSTALLPROPERTY_PACKAGENAMEW, szPath);
2425     ok(hr == DISP_E_EXCEPTION, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2426     ok_exception(hr, szProductInfoException);
2427
2428     /* NULL attribute and NULL product code */
2429     memset(szPath, 0, sizeof(szPath));
2430     hr = Installer_ProductInfo(NULL, NULL, szPath);
2431     ok(hr == DISP_E_EXCEPTION, "Installer_ProductInfo failed, hresult 0x%08x\n", hr);
2432     ok_exception(hr, szProductInfoException);
2433
2434     /* Installer::Products */
2435     test_Installer_Products(FALSE);
2436
2437     /* Installer::RelatedProducts for our upgrade code, should not find anything */
2438     hr = Installer_RelatedProducts(szUpgradeCode, &pStringList);
2439     ok(hr == S_OK, "Installer_RelatedProducts failed, hresult 0x%08x\n", hr);
2440     if (hr == S_OK)
2441     {
2442         /* StringList::Count */
2443         hr = StringList_Count(pStringList, &iCount);
2444         ok(hr == S_OK, "StringList_Count failed, hresult 0x%08x\n", hr);
2445         ok(!iCount, "Expected no related products but found %d\n", iCount);
2446
2447         IDispatch_Release(pStringList);
2448     }
2449
2450     /* Installer::Version */
2451     memset(szPath, 0, sizeof(szPath));
2452     hr = Installer_VersionGet(szPath);
2453     ok(hr == S_OK, "Installer_VersionGet failed, hresult 0x%08x\n", hr);
2454
2455     /* Installer::InstallProduct and other tests that depend on our product being installed */
2456     test_Installer_InstallProduct();
2457 }
2458
2459 START_TEST(automation)
2460 {
2461     DWORD len;
2462     char temp_path[MAX_PATH], prev_path[MAX_PATH];
2463     HRESULT hr;
2464     CLSID clsid;
2465     IUnknown *pUnk;
2466
2467     GetSystemTimeAsFileTime(&systemtime);
2468
2469     GetCurrentDirectoryA(MAX_PATH, prev_path);
2470     GetTempPath(MAX_PATH, temp_path);
2471     SetCurrentDirectoryA(temp_path);
2472
2473     lstrcpyA(CURR_DIR, temp_path);
2474     len = lstrlenA(CURR_DIR);
2475
2476     if(len && (CURR_DIR[len - 1] == '\\'))
2477         CURR_DIR[len - 1] = 0;
2478
2479     get_program_files_dir(PROG_FILES_DIR);
2480
2481     hr = OleInitialize(NULL);
2482     ok (hr == S_OK, "OleInitialize returned 0x%08x\n", hr);
2483     hr = CLSIDFromProgID(szProgId, &clsid);
2484     ok (hr == S_OK, "CLSIDFromProgID returned 0x%08x\n", hr);
2485     hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
2486     ok(hr == S_OK, "CoCreateInstance returned 0x%08x\n", hr);
2487
2488     if (pUnk)
2489     {
2490         hr = IUnknown_QueryInterface(pUnk, &IID_IDispatch, (void **)&pInstaller);
2491         ok (hr == S_OK, "IUnknown::QueryInterface returned 0x%08x\n", hr);
2492
2493         test_dispid();
2494         test_dispatch();
2495         test_Installer();
2496
2497         IDispatch_Release(pInstaller);
2498         IUnknown_Release(pUnk);
2499     }
2500
2501     OleUninitialize();
2502
2503     SetCurrentDirectoryA(prev_path);
2504 }