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 <windows.h>
  27 #include <msiquery.h>
  28 #include <msidefs.h>
  29 #include <msi.h>
  30 #include <fci.h>
  31
  32 #include "wine/test.h"
  33
  34 static const char *msifile = "winetest.msi";
  35 static const WCHAR szMsifile[] = {'w','i','n','e','t','e','s','t','.','m','s','i',0};
  36 CHAR CURR_DIR[MAX_PATH];
  37 EXCEPINFO excepinfo;
  38
  39 /*
  40  * OLE automation data
  41  **/
  42 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 };
  43 static IDispatch *pInstaller;
  44
  45 /* msi database data */
  46
  47 static const CHAR component_dat[] = "Component\tComponentId\tDirectory_\tAttributes\tCondition\tKeyPath\n"
  48                                     "s72\tS38\ts72\ti2\tS255\tS72\n"
  49                                     "Component\tComponent\n"
  50                                     "Five\t{8CC92E9D-14B2-4CA4-B2AA-B11D02078087}\tNEWDIR\t2\t\tfive.txt\n"
  51                                     "Four\t{FD37B4EA-7209-45C0-8917-535F35A2F080}\tCABOUTDIR\t2\t\tfour.txt\n"
  52                                     "One\t{783B242E-E185-4A56-AF86-C09815EC053C}\tMSITESTDIR\t2\t\tone.txt\n"
  53                                     "Three\t{010B6ADD-B27D-4EDD-9B3D-34C4F7D61684}\tCHANGEDDIR\t2\t\tthree.txt\n"
  54                                     "Two\t{BF03D1A6-20DA-4A65-82F3-6CAC995915CE}\tFIRSTDIR\t2\t\ttwo.txt\n"
  55                                     "dangler\t{6091DF25-EF96-45F1-B8E9-A9B1420C7A3C}\tTARGETDIR\t4\t\tregdata\n"
  56                                     "component\t\tMSITESTDIR\t0\t1\tfile\n"
  57                                     "service_comp\t\tMSITESTDIR\t0\t1\tservice_file";
  58
  59 static const CHAR directory_dat[] = "Directory\tDirectory_Parent\tDefaultDir\n"
  60                                     "s72\tS72\tl255\n"
  61                                     "Directory\tDirectory\n"
  62                                     "CABOUTDIR\tMSITESTDIR\tcabout\n"
  63                                     "CHANGEDDIR\tMSITESTDIR\tchanged:second\n"
  64                                     "FIRSTDIR\tMSITESTDIR\tfirst\n"
  65                                     "MSITESTDIR\tProgramFilesFolder\tmsitest\n"
  66                                     "NEWDIR\tCABOUTDIR\tnew\n"
  67                                     "ProgramFilesFolder\tTARGETDIR\t.\n"
  68                                     "TARGETDIR\t\tSourceDir";
  69
  70 static const CHAR feature_dat[] = "Feature\tFeature_Parent\tTitle\tDescription\tDisplay\tLevel\tDirectory_\tAttributes\n"
  71                                   "s38\tS38\tL64\tL255\tI2\ti2\tS72\ti2\n"
  72                                   "Feature\tFeature\n"
  73                                   "Five\t\tFive\tThe Five Feature\t5\t3\tNEWDIR\t0\n"
  74                                   "Four\t\tFour\tThe Four Feature\t4\t3\tCABOUTDIR\t0\n"
  75                                   "One\t\tOne\tThe One Feature\t1\t3\tMSITESTDIR\t0\n"
  76                                   "Three\tOne\tThree\tThe Three Feature\t3\t3\tCHANGEDDIR\t0\n"
  77                                   "Two\tOne\tTwo\tThe Two Feature\t2\t3\tFIRSTDIR\t0\n"
  78                                   "feature\t\t\t\t2\t1\tTARGETDIR\t0\n"
  79                                   "service_feature\t\t\t\t2\t1\tTARGETDIR\t0";
  80
  81 static const CHAR feature_comp_dat[] = "Feature_\tComponent_\n"
  82                                        "s38\ts72\n"
  83                                        "FeatureComponents\tFeature_\tComponent_\n"
  84                                        "Five\tFive\n"
  85                                        "Four\tFour\n"
  86                                        "One\tOne\n"
  87                                        "Three\tThree\n"
  88                                        "Two\tTwo\n"
  89                                        "feature\tcomponent\n"
  90                                        "service_feature\tservice_comp\n";
  91
  92 static const CHAR file_dat[] = "File\tComponent_\tFileName\tFileSize\tVersion\tLanguage\tAttributes\tSequence\n"
  93                                "s72\ts72\tl255\ti4\tS72\tS20\tI2\ti2\n"
  94                                "File\tFile\n"
  95                                "five.txt\tFive\tfive.txt\t1000\t\t\t16384\t5\n"
  96                                "four.txt\tFour\tfour.txt\t1000\t\t\t16384\t4\n"
  97                                "one.txt\tOne\tone.txt\t1000\t\t\t0\t1\n"
  98                                "three.txt\tThree\tthree.txt\t1000\t\t\t0\t3\n"
  99                                "two.txt\tTwo\ttwo.txt\t1000\t\t\t0\t2\n"
 100                                "file\tcomponent\tfilename\t100\t\t\t8192\t1\n"
 101                                "service_file\tservice_comp\tservice.exe\t100\t\t\t8192\t1";
 102
 103 static const CHAR install_exec_seq_dat[] = "Action\tCondition\tSequence\n"
 104                                            "s72\tS255\tI2\n"
 105                                            "InstallExecuteSequence\tAction\n"
 106                                            "AllocateRegistrySpace\tNOT Installed\t1550\n"
 107                                            "CostFinalize\t\t1000\n"
 108                                            "CostInitialize\t\t800\n"
 109                                            "FileCost\t\t900\n"
 110                                            "InstallFiles\t\t4000\n"
 111                                            "InstallServices\t\t5000\n"
 112                                            "InstallFinalize\t\t6600\n"
 113                                            "InstallInitialize\t\t1500\n"
 114                                            "InstallValidate\t\t1400\n"
 115                                            "LaunchConditions\t\t100\n"
 116                                            "WriteRegistryValues\tSourceDir And SOURCEDIR\t5000";
 117
 118 static const CHAR media_dat[] = "DiskId\tLastSequence\tDiskPrompt\tCabinet\tVolumeLabel\tSource\n"
 119                                 "i2\ti4\tL64\tS255\tS32\tS72\n"
 120                                 "Media\tDiskId\n"
 121                                 "1\t3\t\t\tDISK1\t\n"
 122                                 "2\t5\t\tmsitest.cab\tDISK2\t\n";
 123
 124 static const CHAR property_dat[] = "Property\tValue\n"
 125                                    "s72\tl0\n"
 126                                    "Property\tProperty\n"
 127                                    "DefaultUIFont\tDlgFont8\n"
 128                                    "HASUIRUN\t0\n"
 129                                    "INSTALLLEVEL\t3\n"
 130                                    "InstallMode\tTypical\n"
 131                                    "Manufacturer\tWine\n"
 132                                    "PIDTemplate\t12345<###-%%%%%%%>@@@@@\n"
 133                                    "ProductCode\t{F1C3AF50-8B56-4A69-A00C-00773FE42F30}\n"
 134                                    "ProductID\tnone\n"
 135                                    "ProductLanguage\t1033\n"
 136                                    "ProductName\tMSITEST\n"
 137                                    "ProductVersion\t1.1.1\n"
 138                                    "PROMPTROLLBACKCOST\tP\n"
 139                                    "Setup\tSetup\n"
 140                                    "UpgradeCode\t{CE067E8D-2E1A-4367-B734-4EB2BDAD6565}";
 141
 142 static const CHAR registry_dat[] = "Registry\tRoot\tKey\tName\tValue\tComponent_\n"
 143                                    "s72\ti2\tl255\tL255\tL0\ts72\n"
 144                                    "Registry\tRegistry\n"
 145                                    "Apples\t2\tSOFTWARE\\Wine\\msitest\tName\timaname\tOne\n"
 146                                    "Oranges\t2\tSOFTWARE\\Wine\\msitest\tnumber\t#314\tTwo\n"
 147                                    "regdata\t2\tSOFTWARE\\Wine\\msitest\tblah\tbad\tdangler\n"
 148                                    "OrderTest\t2\tSOFTWARE\\Wine\\msitest\tOrderTestName\tOrderTestValue\tcomponent";
 149
 150 static const CHAR service_install_dat[] = "ServiceInstall\tName\tDisplayName\tServiceType\tStartType\tErrorControl\t"
 151                                           "LoadOrderGroup\tDependencies\tStartName\tPassword\tArguments\tComponent_\tDescription\n"
 152                                           "s72\ts255\tL255\ti4\ti4\ti4\tS255\tS255\tS255\tS255\tS255\ts72\tL255\n"
 153                                           "ServiceInstall\tServiceInstall\n"
 154                                           "TestService\tTestService\tTestService\t2\t3\t0\t\t\tTestService\t\t\tservice_comp\t\t";
 155
 156 static const CHAR service_control_dat[] = "ServiceControl\tName\tEvent\tArguments\tWait\tComponent_\n"
 157                                           "s72\tl255\ti2\tL255\tI2\ts72\n"
 158                                           "ServiceControl\tServiceControl\n"
 159                                           "ServiceControl\tTestService\t8\t\t0\tservice_comp";
 160
 161 typedef struct _msi_table
 162 {
 163     const CHAR *filename;
 164     const CHAR *data;
 165     int size;
 166 } msi_table;
 167
 168 #define ADD_TABLE(x) {#x".idt", x##_dat, sizeof(x##_dat)}
 169
 170 static const msi_table tables[] =
 171 {
 172     ADD_TABLE(component),
 173     ADD_TABLE(directory),
 174     ADD_TABLE(feature),
 175     ADD_TABLE(feature_comp),
 176     ADD_TABLE(file),
 177     ADD_TABLE(install_exec_seq),
 178     ADD_TABLE(media),
 179     ADD_TABLE(property),
 180     ADD_TABLE(registry),
 181     ADD_TABLE(service_install),
 182     ADD_TABLE(service_control)
 183 };
 184
 185 /*
 186  * Database Helpers
 187  */
 188
 189 static void write_file(const CHAR *filename, const char *data, int data_size)
 190 {
 191     DWORD size;
 192
 193     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
 194                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 195
 196     WriteFile(hf, data, data_size, &size, NULL);
 197     CloseHandle(hf);
 198 }
 199
 200 static void write_msi_summary_info(MSIHANDLE db)
 201 {
 202     MSIHANDLE summary;
 203     UINT r;
 204
 205     r = MsiGetSummaryInformationA(db, NULL, 4, &summary);
 206     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 207
 208     r = MsiSummaryInfoSetPropertyA(summary, PID_TEMPLATE, VT_LPSTR, 0, NULL, ";1033");
 209     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 210
 211     r = MsiSummaryInfoSetPropertyA(summary, PID_REVNUMBER, VT_LPSTR, 0, NULL,
 212                                    "{004757CA-5092-49c2-AD20-28E1CE0DF5F2}");
 213     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 214
 215     r = MsiSummaryInfoSetPropertyA(summary, PID_PAGECOUNT, VT_I4, 100, NULL, NULL);
 216     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 217
 218     r = MsiSummaryInfoSetPropertyA(summary, PID_WORDCOUNT, VT_I4, 0, NULL, NULL);
 219     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 220
 221     /* write the summary changes back to the stream */
 222     r = MsiSummaryInfoPersist(summary);
 223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 224
 225     MsiCloseHandle(summary);
 226 }
 227
 228 static void create_database(const CHAR *name, const msi_table *tables, int num_tables)
 229 {
 230     MSIHANDLE db;
 231     UINT r;
 232     int j;
 233
 234     r = MsiOpenDatabaseA(name, MSIDBOPEN_CREATE, &db);
 235     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 236
 237     /* import the tables into the database */
 238     for (j = 0; j < num_tables; j++)
 239     {
 240         const msi_table *table = &tables[j];
 241
 242         write_file(table->filename, table->data, (table->size - 1) * sizeof(char));
 243
 244         r = MsiDatabaseImportA(db, CURR_DIR, table->filename);
 245         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 246
 247         DeleteFileA(table->filename);
 248     }
 249
 250     write_msi_summary_info(db);
 251
 252     r = MsiDatabaseCommit(db);
 253     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 254
 255     MsiCloseHandle(db);
 256 }
 257
 258 /*
 259  * Automation helpers and tests
 260  */
 261
 262 /* ok-like statement which takes two unicode strings as arguments */
 263 static CHAR string1[MAX_PATH], string2[MAX_PATH];
 264 static UINT len;
 265
 266 #define ok_w2(format, szString1, szString2) \
 267 \
 268     if (lstrcmpW(szString1, szString2) != 0) \
 269     { \
 270         len = WideCharToMultiByte(CP_ACP, 0, szString1, -1, string1, MAX_PATH, NULL, NULL); \
 271         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError()); \
 272 \
 273         len = WideCharToMultiByte(CP_ACP, 0, szString2, -1, string2, MAX_PATH, NULL, NULL); \
 274         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError()); \
 275 \
 276         ok(0, format, string1, string2); \
 277     }
 278
 279 /* exception checker */
 280 static WCHAR szSource[] = {'M','s','i',' ','A','P','I',' ','E','r','r','o','r',0};
 281
 282 #define ok_exception(hr, szDescription)           \
 283     if (hr == DISP_E_EXCEPTION) \
 284     { \
 285         /* Compare wtype, source, and destination */                    \
 286         ok(excepinfo.wCode == 1000, "Exception info was %d, expected 1000\n", excepinfo.wCode); \
 287 \
 288         ok(excepinfo.bstrSource != NULL, "Exception source was NULL\n"); \
 289         if (excepinfo.bstrSource)                                       \
 290             ok_w2("Exception source was \"%s\" but expected to be \"%s\"\n", excepinfo.bstrSource, szSource); \
 291 \
 292         ok(excepinfo.bstrDescription != NULL, "Exception description was NULL\n"); \
 293         if (excepinfo.bstrDescription && lstrcmpW(excepinfo.bstrDescription, szDescription) != 0)                    \
 294         {                                                               \
 295             len = WideCharToMultiByte(CP_ACP, 0, excepinfo.bstrDescription, -1, string1, MAX_PATH, NULL, NULL); \
 296             ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError()); \
 297                                                                         \
 298             len = WideCharToMultiByte(CP_ACP, 0, szDescription, -1, string2, MAX_PATH, NULL, NULL); \
 299             ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError()); \
 300                                                                         \
 301             todo_wine {                                                 \
 302                 /* Our parameter names are different so the descriptions will not match */ \
 303                 ok(0, "Exception description was \"%s\" but expected to be \"%s\"\n", string1, string2);                        \
 304             }                                                           \
 305         }                                                               \
 306     }
 307
 308 static DISPID get_dispid( IDispatch *disp, const char *name )
 309 {
 310     LPOLESTR str;
 311     UINT len;
 312     DISPID id = -1;
 313     HRESULT r;
 314
 315     len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0 );
 316     str = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR) );
 317     if (str)
 318     {
 319         len = MultiByteToWideChar(CP_ACP, 0, name, -1, str, len );
 320         r = IDispatch_GetIDsOfNames( disp, &IID_NULL, &str, 1, 0, &id );
 321         HeapFree(GetProcessHeap(), 0, str);
 322         if (r != S_OK)
 323             return -1;
 324     }
 325
 326     return id;
 327 }
 328
 329 static void test_dispid(void)
 330 {
 331     ok( get_dispid( pInstaller, "OpenPackage" ) == 2, "dispid wrong\n");
 332
 333     todo_wine {
 334     ok( get_dispid( pInstaller, "CreateRecord" ) == 1, "dispid wrong\n");
 335     ok( get_dispid( pInstaller, "OpenProduct" ) == 3, "dispid wrong\n");
 336     ok( get_dispid( pInstaller, "OpenDatabase" ) == 4, "dispid wrong\n");
 337     ok( get_dispid( pInstaller, "SummaryInformation" ) == 5, "dispid wrong\n");
 338     ok( get_dispid( pInstaller, "UILevel" ) == 6, "dispid wrong\n");
 339     ok( get_dispid( pInstaller, "EnableLog" ) == 7, "dispid wrong\n");
 340     ok( get_dispid( pInstaller, "InstallProduct" ) == 8, "dispid wrong\n");
 341     ok( get_dispid( pInstaller, "Version" ) == 9, "dispid wrong\n");
 342     ok( get_dispid( pInstaller, "LastErrorRecord" ) == 10, "dispid wrong\n");
 343     ok( get_dispid( pInstaller, "RegistryValue" ) == 11, "dispid wrong\n");
 344     ok( get_dispid( pInstaller, "Environment" ) == 12, "dispid wrong\n");
 345     ok( get_dispid( pInstaller, "FileAttributes" ) == 13, "dispid wrong\n");
 346
 347     ok( get_dispid( pInstaller, "FileSize" ) == 15, "dispid wrong\n");
 348     ok( get_dispid( pInstaller, "FileVersion" ) == 16, "dispid wrong\n");
 349     ok( get_dispid( pInstaller, "ProductState" ) == 17, "dispid wrong\n");
 350     ok( get_dispid( pInstaller, "ProductInfo" ) == 18, "dispid wrong\n");
 351     ok( get_dispid( pInstaller, "ConfigureProduct" ) == 19, "dispid wrong\n");
 352     ok( get_dispid( pInstaller, "ReinstallProduct" ) == 20 , "dispid wrong\n");
 353     ok( get_dispid( pInstaller, "CollectUserInfo" ) == 21, "dispid wrong\n");
 354     ok( get_dispid( pInstaller, "ApplyPatch" ) == 22, "dispid wrong\n");
 355     ok( get_dispid( pInstaller, "FeatureParent" ) == 23, "dispid wrong\n");
 356     ok( get_dispid( pInstaller, "FeatureState" ) == 24, "dispid wrong\n");
 357     ok( get_dispid( pInstaller, "UseFeature" ) == 25, "dispid wrong\n");
 358     ok( get_dispid( pInstaller, "FeatureUsageCount" ) == 26, "dispid wrong\n");
 359     ok( get_dispid( pInstaller, "FeatureUsageDate" ) == 27, "dispid wrong\n");
 360     ok( get_dispid( pInstaller, "ConfigureFeature" ) == 28, "dispid wrong\n");
 361     ok( get_dispid( pInstaller, "ReinstallFeature" ) == 29, "dispid wrong\n");
 362     ok( get_dispid( pInstaller, "ProvideComponent" ) == 30, "dispid wrong\n");
 363     ok( get_dispid( pInstaller, "ComponentPath" ) == 31, "dispid wrong\n");
 364     ok( get_dispid( pInstaller, "ProvideQualifiedComponent" ) == 32, "dispid wrong\n");
 365     ok( get_dispid( pInstaller, "QualifierDescription" ) == 33, "dispid wrong\n");
 366     ok( get_dispid( pInstaller, "ComponentQualifiers" ) == 34, "dispid wrong\n");
 367     ok( get_dispid( pInstaller, "Products" ) == 35, "dispid wrong\n");
 368     ok( get_dispid( pInstaller, "Features" ) == 36, "dispid wrong\n");
 369     ok( get_dispid( pInstaller, "Components" ) == 37, "dispid wrong\n");
 370     ok( get_dispid( pInstaller, "ComponentClients" ) == 38, "dispid wrong\n");
 371     ok( get_dispid( pInstaller, "Patches" ) == 39, "dispid wrong\n");
 372     ok( get_dispid( pInstaller, "RelatedProducts" ) == 40, "dispid wrong\n");
 373     ok( get_dispid( pInstaller, "PatchInfo" ) == 41, "dispid wrong\n");
 374     ok( get_dispid( pInstaller, "PatchTransforms" ) == 42, "dispid wrong\n");
 375     ok( get_dispid( pInstaller, "AddSource" ) == 43, "dispid wrong\n");
 376     ok( get_dispid( pInstaller, "ClearSourceList" ) == 44, "dispid wrong\n");
 377     ok( get_dispid( pInstaller, "ForceSourceListResolution" ) == 45, "dispid wrong\n");
 378     ok( get_dispid( pInstaller, "ShortcutTarget" ) == 46, "dispid wrong\n");
 379     ok( get_dispid( pInstaller, "FileHash" ) == 47, "dispid wrong\n");
 380     ok( get_dispid( pInstaller, "FileSignatureInfo" ) == 48, "dispid wrong\n");
 381     ok( get_dispid( pInstaller, "RemovePatches" ) == 49, "dispid wrong\n");
 382
 383     ok( get_dispid( pInstaller, "ApplyMultiplePatches" ) == 51, "dispid wrong\n");
 384     ok( get_dispid( pInstaller, "ProductsEx" ) ==  52, "dispid wrong\n");
 385
 386     ok( get_dispid( pInstaller, "PatchesEx" ) == 55, "dispid wrong\n");
 387
 388     ok( get_dispid( pInstaller, "ExtractPatchXMLData" ) == 57, "dispid wrong\n");
 389     }
 390
 391     /* MSDN claims the following functions exist but IDispatch->GetIDsOfNames disagrees */
 392     if (0)
 393     {
 394         get_dispid( pInstaller, "ProductElevated" );
 395         get_dispid( pInstaller, "ProductInfoFromScript" );
 396         get_dispid( pInstaller, "ProvideAssembly" );
 397         get_dispid( pInstaller, "CreateAdvertiseScript" );
 398         get_dispid( pInstaller, "AdvertiseProduct" );
 399         get_dispid( pInstaller, "PatchFiles" );
 400     }
 401 }
 402
 403 /* Test basic IDispatch functions */
 404 static void test_dispatch(void)
 405 {
 406     static WCHAR szOpenPackage[] = { 'O','p','e','n','P','a','c','k','a','g','e',0 };
 407     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};
 408     HRESULT hr;
 409     DISPID dispid;
 410     OLECHAR *name;
 411     VARIANT varresult;
 412     VARIANTARG vararg[2];
 413     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 414
 415     /* Test getting ID of a function name that does not exist */
 416     name = (WCHAR *)szMsifile;
 417     hr = IDispatch_GetIDsOfNames(pInstaller, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 418     ok(hr == DISP_E_UNKNOWNNAME, "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 419
 420     /* Test invoking this function */
 421     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 422     ok(hr == DISP_E_MEMBERNOTFOUND, "IDispatch::Invoke returned 0x%08x\n", hr);
 423
 424     /* Test getting ID of a function name that does exist */
 425     name = (WCHAR *)szOpenPackage;
 426     hr = IDispatch_GetIDsOfNames(pInstaller, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 427     ok(SUCCEEDED(hr), "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 428
 429     /* Test invoking this function (without parameters passed) */
 430     if (0) /* All of these crash MSI on Windows XP */
 431     {
 432         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, NULL, NULL);
 433         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, NULL, &excepinfo, NULL);
 434         VariantInit(&varresult);
 435         hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, NULL, &varresult, &excepinfo, NULL);
 436     }
 437
 438     /* Try with NULL params */
 439     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 440     todo_wine ok(hr == DISP_E_TYPEMISMATCH, "IDispatch::Invoke returned 0x%08x\n", hr);
 441
 442     /* Try one empty parameter */
 443     dispparams.rgvarg = vararg;
 444     dispparams.cArgs = 1;
 445     VariantInit(&vararg[0]);
 446     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 447     todo_wine ok(hr == DISP_E_TYPEMISMATCH, "IDispatch::Invoke returned 0x%08x\n", hr);
 448
 449     /* Try one parameter, function requires two */
 450     VariantInit(&vararg[0]);
 451     V_VT(&vararg[0]) = VT_BSTR;
 452     V_BSTR(&vararg[0]) = SysAllocString(szMsifile);
 453     hr = IDispatch_Invoke(pInstaller, dispid, &IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dispparams, &varresult, &excepinfo, NULL);
 454     VariantClear(&vararg[0]);
 455
 456     ok(hr == DISP_E_EXCEPTION, "IDispatch::Invoke returned 0x%08x\n", hr);
 457     ok_exception(hr, szOpenPackageException);
 458 }
 459
 460 /* invocation helper function */
 461 static HRESULT invoke(IDispatch *pDispatch, LPCSTR szName, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, VARTYPE vtResult)
 462 {
 463     OLECHAR *name = NULL;
 464     DISPID dispid;
 465     HRESULT hr;
 466     int i;
 467     UINT len;
 468
 469     memset(pVarResult, 0, sizeof(VARIANT));
 470     VariantInit(pVarResult);
 471
 472     len = MultiByteToWideChar(CP_ACP, 0, szName, -1, NULL, 0 );
 473     name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR) );
 474     if (!name) return E_FAIL;
 475     len = MultiByteToWideChar(CP_ACP, 0, szName, -1, name, len );
 476     hr = IDispatch_GetIDsOfNames(pDispatch, &IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
 477     HeapFree(GetProcessHeap(), 0, name);
 478     ok(SUCCEEDED(hr), "IDispatch::GetIDsOfNames returned 0x%08x\n", hr);
 479     if (!SUCCEEDED(hr)) return hr;
 480
 481     memset(&excepinfo, 0, sizeof(excepinfo));
 482     hr = IDispatch_Invoke(pDispatch, dispid, &IID_NULL, LOCALE_NEUTRAL, wFlags, pDispParams, pVarResult, &excepinfo, NULL);
 483
 484     if (SUCCEEDED(hr))
 485     {
 486         ok(V_VT(pVarResult) == vtResult, "Variant result type is %d, expected %d\n", V_VT(pVarResult), vtResult);
 487         if (vtResult != VT_EMPTY)
 488         {
 489             hr = VariantChangeTypeEx(pVarResult, pVarResult, LOCALE_NEUTRAL, 0, vtResult);
 490             ok(SUCCEEDED(hr), "VariantChangeTypeEx returned 0x%08x\n", hr);
 491         }
 492     }
 493
 494     for (i=0; i<pDispParams->cArgs; i++)
 495         VariantClear(&pDispParams->rgvarg[i]);
 496
 497     return hr;
 498 }
 499
 500 /* Object_Property helper functions */
 501
 502 static HRESULT Installer_CreateRecord(int count, IDispatch **pRecord)
 503 {
 504     VARIANT varresult;
 505     VARIANTARG vararg[1];
 506     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 507     HRESULT hr;
 508
 509     VariantInit(&vararg[0]);
 510     V_VT(&vararg[0]) = VT_I4;
 511     V_I4(&vararg[0]) = count;
 512
 513     hr = invoke(pInstaller, "CreateRecord", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 514     *pRecord = V_DISPATCH(&varresult);
 515     return hr;
 516 }
 517
 518 static HRESULT Installer_OpenPackage(LPCWSTR szPackagePath, int options, IDispatch **pSession)
 519 {
 520     VARIANT varresult;
 521     VARIANTARG vararg[2];
 522     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 523     HRESULT hr;
 524
 525     VariantInit(&vararg[1]);
 526     V_VT(&vararg[1]) = VT_BSTR;
 527     V_BSTR(&vararg[1]) = SysAllocString(szPackagePath);
 528     VariantInit(&vararg[0]);
 529     V_VT(&vararg[0]) = VT_I4;
 530     V_I4(&vararg[0]) = options;
 531
 532     hr = invoke(pInstaller, "OpenPackage", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 533     *pSession = V_DISPATCH(&varresult);
 534     return hr;
 535 }
 536
 537 static HRESULT Installer_VersionGet(LPCWSTR szVersion)
 538 {
 539     VARIANT varresult;
 540     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 541     HRESULT hr;
 542
 543     hr = invoke(pInstaller, "Version", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 544     lstrcpyW((WCHAR *)szVersion, V_BSTR(&varresult));
 545     VariantClear(&varresult);
 546     return hr;
 547 }
 548
 549 static HRESULT Session_PropertyGet(IDispatch *pSession, LPCWSTR szName, LPCWSTR szReturn)
 550 {
 551     VARIANT varresult;
 552     VARIANTARG vararg[1];
 553     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 554     HRESULT hr;
 555
 556     VariantInit(&vararg[0]);
 557     V_VT(&vararg[0]) = VT_BSTR;
 558     V_BSTR(&vararg[0]) = SysAllocString(szName);
 559
 560     hr = invoke(pSession, "Property", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 561     lstrcpyW((WCHAR *)szReturn, V_BSTR(&varresult));
 562     VariantClear(&varresult);
 563     return hr;
 564 }
 565
 566 static HRESULT Session_PropertyPut(IDispatch *pSession, LPCWSTR szName, LPCWSTR szValue)
 567 {
 568     VARIANT varresult;
 569     VARIANTARG vararg[2];
 570     DISPID dispid = DISPID_PROPERTYPUT;
 571     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 572
 573     VariantInit(&vararg[1]);
 574     V_VT(&vararg[1]) = VT_BSTR;
 575     V_BSTR(&vararg[1]) = SysAllocString(szName);
 576     VariantInit(&vararg[0]);
 577     V_VT(&vararg[0]) = VT_BSTR;
 578     V_BSTR(&vararg[0]) = SysAllocString(szValue);
 579
 580     return invoke(pSession, "Property", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
 581 }
 582
 583 static HRESULT Session_LanguageGet(IDispatch *pSession, UINT *pLangId)
 584 {
 585     VARIANT varresult;
 586     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 587     HRESULT hr;
 588
 589     hr = invoke(pSession, "Language", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 590     *pLangId = V_I4(&varresult);
 591     VariantClear(&varresult);
 592     return hr;
 593 }
 594
 595 static HRESULT Session_ModeGet(IDispatch *pSession, int iFlag, BOOL *pMode)
 596 {
 597     VARIANT varresult;
 598     VARIANTARG vararg[1];
 599     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 600     HRESULT hr;
 601
 602     VariantInit(&vararg[0]);
 603     V_VT(&vararg[0]) = VT_I4;
 604     V_I4(&vararg[0]) = iFlag;
 605
 606     hr = invoke(pSession, "Mode", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BOOL);
 607     *pMode = V_BOOL(&varresult);
 608     VariantClear(&varresult);
 609     return hr;
 610 }
 611
 612 static HRESULT Session_ModePut(IDispatch *pSession, int iFlag, BOOL bMode)
 613 {
 614     VARIANT varresult;
 615     VARIANTARG vararg[2];
 616     DISPID dispid = DISPID_PROPERTYPUT;
 617     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 618
 619     VariantInit(&vararg[1]);
 620     V_VT(&vararg[1]) = VT_I4;
 621     V_I4(&vararg[1]) = iFlag;
 622     VariantInit(&vararg[0]);
 623     V_VT(&vararg[0]) = VT_BOOL;
 624     V_BOOL(&vararg[0]) = bMode;
 625
 626     return invoke(pSession, "Mode", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
 627 }
 628
 629 static HRESULT Session_Database(IDispatch *pSession, IDispatch **pDatabase)
 630 {
 631     VARIANT varresult;
 632     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 633     HRESULT hr;
 634
 635     hr = invoke(pSession, "Database", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_DISPATCH);
 636     *pDatabase = V_DISPATCH(&varresult);
 637     return hr;
 638 }
 639
 640 static HRESULT Session_DoAction(IDispatch *pSession, LPCWSTR szAction, int *iReturn)
 641 {
 642     VARIANT varresult;
 643     VARIANTARG vararg[1];
 644     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 645     HRESULT hr;
 646
 647     VariantInit(&vararg[0]);
 648     V_VT(&vararg[0]) = VT_BSTR;
 649     V_BSTR(&vararg[0]) = SysAllocString(szAction);
 650
 651     hr = invoke(pSession, "DoAction", DISPATCH_METHOD, &dispparams, &varresult, VT_I4);
 652     *iReturn = V_I4(&varresult);
 653     VariantClear(&varresult);
 654     return hr;
 655 }
 656
 657 static HRESULT Session_SetInstallLevel(IDispatch *pSession, long iInstallLevel)
 658 {
 659     VARIANT varresult;
 660     VARIANTARG vararg[1];
 661     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 662
 663     VariantInit(&vararg[0]);
 664     V_VT(&vararg[0]) = VT_I4;
 665     V_I4(&vararg[0]) = iInstallLevel;
 666
 667     return invoke(pSession, "SetInstallLevel", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
 668 }
 669
 670 static HRESULT Session_FeatureCurrentState(IDispatch *pSession, LPCWSTR szName, int *pState)
 671 {
 672     VARIANT varresult;
 673     VARIANTARG vararg[1];
 674     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 675     HRESULT hr;
 676
 677     VariantInit(&vararg[0]);
 678     V_VT(&vararg[0]) = VT_BSTR;
 679     V_BSTR(&vararg[0]) = SysAllocString(szName);
 680
 681     hr = invoke(pSession, "FeatureCurrentState", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 682     *pState = V_I4(&varresult);
 683     VariantClear(&varresult);
 684     return hr;
 685 }
 686
 687 static HRESULT Session_FeatureRequestStateGet(IDispatch *pSession, LPCWSTR szName, int *pState)
 688 {
 689     VARIANT varresult;
 690     VARIANTARG vararg[1];
 691     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 692     HRESULT hr;
 693
 694     VariantInit(&vararg[0]);
 695     V_VT(&vararg[0]) = VT_BSTR;
 696     V_BSTR(&vararg[0]) = SysAllocString(szName);
 697
 698     hr = invoke(pSession, "FeatureRequestState", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 699     *pState = V_I4(&varresult);
 700     VariantClear(&varresult);
 701     return hr;
 702 }
 703
 704 static HRESULT Session_FeatureRequestStatePut(IDispatch *pSession, LPCWSTR szName, int iState)
 705 {
 706     VARIANT varresult;
 707     VARIANTARG vararg[2];
 708     DISPID dispid = DISPID_PROPERTYPUT;
 709     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 710
 711     VariantInit(&vararg[1]);
 712     V_VT(&vararg[1]) = VT_BSTR;
 713     V_BSTR(&vararg[1]) = SysAllocString(szName);
 714     VariantInit(&vararg[0]);
 715     V_VT(&vararg[0]) = VT_I4;
 716     V_I4(&vararg[0]) = iState;
 717
 718     return invoke(pSession, "FeatureRequestState", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_EMPTY);
 719 }
 720
 721 static HRESULT Database_OpenView(IDispatch *pDatabase, LPCWSTR szSql, IDispatch **pView)
 722 {
 723     VARIANT varresult;
 724     VARIANTARG vararg[1];
 725     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 726     HRESULT hr;
 727
 728     VariantInit(&vararg[0]);
 729     V_VT(&vararg[0]) = VT_BSTR;
 730     V_BSTR(&vararg[0]) = SysAllocString(szSql);
 731
 732     hr = invoke(pDatabase, "OpenView", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 733     *pView = V_DISPATCH(&varresult);
 734     return hr;
 735 }
 736
 737 static HRESULT View_Execute(IDispatch *pView, IDispatch *pRecord)
 738 {
 739     VARIANT varresult;
 740     VARIANTARG vararg[1];
 741     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 742
 743     VariantInit(&vararg[0]);
 744     V_VT(&vararg[0]) = VT_DISPATCH;
 745     V_DISPATCH(&vararg[0]) = pRecord;
 746
 747     return invoke(pView, "Execute", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
 748 }
 749
 750 static HRESULT View_Fetch(IDispatch *pView, IDispatch **ppRecord)
 751 {
 752     VARIANT varresult;
 753     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 754     HRESULT hr = invoke(pView, "Fetch", DISPATCH_METHOD, &dispparams, &varresult, VT_DISPATCH);
 755     *ppRecord = V_DISPATCH(&varresult);
 756     return hr;
 757 }
 758
 759 static HRESULT View_Close(IDispatch *pView)
 760 {
 761     VARIANT varresult;
 762     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 763     return invoke(pView, "Close", DISPATCH_METHOD, &dispparams, &varresult, VT_EMPTY);
 764 }
 765
 766 static HRESULT Record_FieldCountGet(IDispatch *pRecord, int *pFieldCount)
 767 {
 768     VARIANT varresult;
 769     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 770     HRESULT hr = invoke(pRecord, "FieldCount", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_I4);
 771     *pFieldCount = V_I4(&varresult);
 772     VariantClear(&varresult);
 773     return hr;
 774 }
 775
 776 static HRESULT Record_StringDataGet(IDispatch *pRecord, int iField, LPCWSTR szString)
 777 {
 778     VARIANT varresult;
 779     VARIANTARG vararg[1];
 780     DISPPARAMS dispparams = {vararg, NULL, sizeof(vararg)/sizeof(VARIANTARG), 0};
 781     HRESULT hr;
 782
 783     VariantInit(&vararg[0]);
 784     V_VT(&vararg[0]) = VT_I4;
 785     V_I4(&vararg[0]) = iField;
 786
 787     hr = invoke(pRecord, "StringData", DISPATCH_PROPERTYGET, &dispparams, &varresult, VT_BSTR);
 788     lstrcpyW((WCHAR *)szString, V_BSTR(&varresult));
 789     VariantClear(&varresult);
 790     return hr;
 791 }
 792
 793 static HRESULT Record_StringDataPut(IDispatch *pRecord, int iField, LPCWSTR szString)
 794 {
 795     VARIANT varresult;
 796     VARIANTARG vararg[2];
 797     DISPID dispid = DISPID_PROPERTYPUT;
 798     DISPPARAMS dispparams = {vararg, &dispid, sizeof(vararg)/sizeof(VARIANTARG), 1};
 799
 800     VariantInit(&vararg[1]);
 801     V_VT(&vararg[1]) = VT_I4;
 802     V_I4(&vararg[1]) = iField;
 803     VariantInit(&vararg[0]);
 804     V_VT(&vararg[0]) = VT_BSTR;
 805     V_BSTR(&vararg[0]) = SysAllocString(szString);
 806
 807     return invoke(pRecord, "StringData", DISPATCH_PROPERTYPUT, &dispparams, &varresult, VT_BSTR);
 808 }
 809
 810 /* Test the various objects */
 811
 812 static void test_Database(IDispatch *pDatabase)
 813 {
 814     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 };
 815     static WCHAR szThree[] = { 'T','h','r','e','e',0 };
 816     static WCHAR szTwo[] = { 'T','w','o',0 };
 817     static WCHAR szStringDataField[] = { 'S','t','r','i','n','g','D','a','t','a',',','F','i','e','l','d',0 };
 818     IDispatch *pView = NULL;
 819     HRESULT hr;
 820
 821     hr = Database_OpenView(pDatabase, szSql, &pView);
 822     ok(SUCCEEDED(hr), "Database_OpenView failed, hresult 0x%08x\n", hr);
 823     if (SUCCEEDED(hr))
 824     {
 825         IDispatch *pRecord = NULL;
 826         WCHAR szString[MAX_PATH];
 827
 828         /* View::Execute */
 829         hr = View_Execute(pView, NULL);
 830         ok(SUCCEEDED(hr), "View_Execute failed, hresult 0x%08x\n", hr);
 831
 832         /* View::Fetch */
 833         hr = View_Fetch(pView, &pRecord);
 834         ok(SUCCEEDED(hr), "View_Fetch failed, hresult 0x%08x\n", hr);
 835         ok(pRecord != NULL, "View_Fetch should not have returned NULL record\n");
 836         if (pRecord)
 837         {
 838             /* Record::StringDataGet */
 839             memset(szString, 0, sizeof(szString));
 840             hr = Record_StringDataGet(pRecord, 1, szString);
 841             ok(SUCCEEDED(hr), "Record_StringDataGet failed, hresult 0x%08x\n", hr);
 842             ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szThree);
 843
 844             /* Record::StringDataPut with incorrect index */
 845             hr = Record_StringDataPut(pRecord, -1, szString);
 846             ok(hr == DISP_E_EXCEPTION, "Record_StringDataPut failed, hresult 0x%08x\n", hr);
 847             ok_exception(hr, szStringDataField);
 848
 849             IDispatch_Release(pRecord);
 850         }
 851
 852         /* View::Fetch */
 853         hr = View_Fetch(pView, &pRecord);
 854         ok(SUCCEEDED(hr), "View_Fetch failed, hresult 0x%08x\n", hr);
 855         ok(pRecord != NULL, "View_Fetch should not have returned NULL record\n");
 856         if (pRecord)
 857         {
 858             /* Record::StringDataGet */
 859             memset(szString, 0, sizeof(szString));
 860             hr = Record_StringDataGet(pRecord, 1, szString);
 861             ok(SUCCEEDED(hr), "Record_StringDataGet failed, hresult 0x%08x\n", hr);
 862             ok_w2("Record_StringDataGet result was %s but expected %s\n", szString, szTwo);
 863
 864             IDispatch_Release(pRecord);
 865         }
 866
 867         /* View::Fetch */
 868         hr = View_Fetch(pView, &pRecord);
 869         ok(SUCCEEDED(hr), "View_Fetch failed, hresult 0x%08x\n", hr);
 870         ok(pRecord == NULL, "View_Fetch should have returned NULL record\n");
 871         if (pRecord)
 872             IDispatch_Release(pRecord);
 873
 874         /* View::Close */
 875         hr = View_Close(pView);
 876         ok(SUCCEEDED(hr), "View_Close failed, hresult 0x%08x\n", hr);
 877
 878         IDispatch_Release(pView);
 879     }
 880 }
 881
 882 static void test_Session(IDispatch *pSession)
 883 {
 884     static WCHAR szProductName[] = { 'P','r','o','d','u','c','t','N','a','m','e',0 };
 885     static WCHAR szMSITEST[] = { 'M','S','I','T','E','S','T',0 };
 886     static WCHAR szOne[] = { 'O','n','e',0 };
 887     static WCHAR szCostInitialize[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
 888     static WCHAR szEmpty[] = { 0 };
 889     static WCHAR szEquals[] = { '=',0 };
 890     static WCHAR szPropertyName[] = { 'P','r','o','p','e','r','t','y',',','N','a','m','e',0 };
 891     WCHAR stringw[MAX_PATH];
 892     CHAR string[MAX_PATH];
 893     UINT len;
 894     BOOL bool;
 895     int myint;
 896     IDispatch *pDatabase = NULL;
 897     HRESULT hr;
 898
 899     /* Session::Property, get */
 900     memset(stringw, 0, sizeof(stringw));
 901     hr = Session_PropertyGet(pSession, szProductName, stringw);
 902     ok(SUCCEEDED(hr), "Session_PropertyGet failed, hresult 0x%08x\n", hr);
 903     if (lstrcmpW(stringw, szMSITEST) != 0)
 904     {
 905         len = WideCharToMultiByte(CP_ACP, 0, stringw, -1, string, MAX_PATH, NULL, NULL);
 906         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError());
 907         ok(0, "Property \"ProductName\" expected to be \"MSITEST\" but was \"%s\"\n", string);
 908     }
 909
 910     /* Session::Property, put */
 911     hr = Session_PropertyPut(pSession, szProductName, szProductName);
 912     ok(SUCCEEDED(hr), "Session_PropertyPut failed, hresult 0x%08x\n", hr);
 913     memset(stringw, 0, sizeof(stringw));
 914     hr = Session_PropertyGet(pSession, szProductName, stringw);
 915     ok(SUCCEEDED(hr), "Session_PropertyGet failed, hresult 0x%08x\n", hr);
 916     if (lstrcmpW(stringw, szProductName) != 0)
 917     {
 918         len = WideCharToMultiByte(CP_ACP, 0, stringw, -1, string, MAX_PATH, NULL, NULL);
 919         ok(len, "WideCharToMultiByteChar returned error %d\n", GetLastError());
 920         ok(0, "Property \"ProductName\" expected to be \"ProductName\" but was \"%s\"\n", string);
 921     }
 922
 923     /* Try putting a property using empty property identifier */
 924     hr = Session_PropertyPut(pSession, szEmpty, szProductName);
 925     ok(hr == DISP_E_EXCEPTION, "Session_PropertyPut failed, hresult 0x%08x\n", hr);
 926     ok_exception(hr, szPropertyName);
 927
 928     /* Try putting a property using illegal property identifier */
 929     hr = Session_PropertyPut(pSession, szEquals, szProductName);
 930     ok(SUCCEEDED(hr), "Session_PropertyPut failed, hresult 0x%08x\n", hr);
 931
 932     /* Session::Language, get */
 933     hr = Session_LanguageGet(pSession, &len);
 934     ok(SUCCEEDED(hr), "Session_LanguageGet failed, hresult 0x%08x\n", hr);
 935     /* Not sure how to check the language is correct */
 936
 937     /* Session::Mode, get */
 938     hr = Session_ModeGet(pSession, MSIRUNMODE_REBOOTATEND, &bool);
 939     ok(SUCCEEDED(hr), "Session_ModeGet failed, hresult 0x%08x\n", hr);
 940     todo_wine ok(!bool, "Reboot at end session mode is %d\n", bool);
 941
 942     /* Session::Mode, put */
 943     hr = Session_ModePut(pSession, MSIRUNMODE_REBOOTATEND, TRUE);
 944     todo_wine ok(SUCCEEDED(hr), "Session_ModePut failed, hresult 0x%08x\n", hr);
 945     hr = Session_ModeGet(pSession, MSIRUNMODE_REBOOTATEND, &bool);
 946     ok(SUCCEEDED(hr), "Session_ModeGet failed, hresult 0x%08x\n", hr);
 947     ok(bool, "Reboot at end session mode is %d, expected 1\n", bool);
 948     hr = Session_ModePut(pSession, MSIRUNMODE_REBOOTATEND, FALSE);  /* set it again so we don't reboot */
 949     todo_wine ok(SUCCEEDED(hr), "Session_ModePut failed, hresult 0x%08x\n", hr);
 950
 951     /* Session::Database, get */
 952     hr = Session_Database(pSession, &pDatabase);
 953     ok(SUCCEEDED(hr), "Session_Database failed, hresult 0x%08x\n", hr);
 954     if (SUCCEEDED(hr))
 955     {
 956         test_Database(pDatabase);
 957         IDispatch_Release(pDatabase);
 958     }
 959
 960     /* Session::DoAction(CostInitialize) must occur before the next statements */
 961     hr = Session_DoAction(pSession, szCostInitialize, &myint);
 962     ok(SUCCEEDED(hr), "Session_DoAction failed, hresult 0x%08x\n", hr);
 963     ok(myint == IDOK, "DoAction(CostInitialize) returned %d, %d expected\n", myint, IDOK);
 964
 965     /* Session::SetInstallLevel */
 966     hr = Session_SetInstallLevel(pSession, INSTALLLEVEL_MINIMUM);
 967     ok(SUCCEEDED(hr), "Session_SetInstallLevel failed, hresult 0x%08x\n", hr);
 968
 969     /* Session::FeatureCurrentState, get */
 970     hr = Session_FeatureCurrentState(pSession, szOne, &myint);
 971     ok(SUCCEEDED(hr), "Session_FeatureCurrentState failed, hresult 0x%08x\n", hr);
 972     ok(myint == INSTALLSTATE_UNKNOWN, "Feature current state was %d but expected %d\n", myint, INSTALLSTATE_UNKNOWN);
 973
 974     /* Session::FeatureRequestState, put */
 975     hr = Session_FeatureRequestStatePut(pSession, szOne, INSTALLSTATE_ADVERTISED);
 976     ok(SUCCEEDED(hr), "Session_FeatureRequestStatePut failed, hresult 0x%08x\n", hr);
 977     hr = Session_FeatureRequestStateGet(pSession, szOne, &myint);
 978     ok(SUCCEEDED(hr), "Session_FeatureRequestStateGet failed, hresult 0x%08x\n", hr);
 979     ok(myint == INSTALLSTATE_ADVERTISED, "Feature request state was %d but expected %d\n", myint, INSTALLSTATE_ADVERTISED);
 980 }
 981
 982 static void test_Installer(void)
 983 {
 984     static WCHAR szBackslash[] = { '\\',0 };
 985     WCHAR szPath[MAX_PATH];
 986     HRESULT hr;
 987     UINT len;
 988     IDispatch *pSession = NULL, *pRecord = NULL;
 989
 990     if (!pInstaller) return;
 991
 992     /* Installer::CreateRecord */
 993     todo_wine {
 994         hr = Installer_CreateRecord(1, &pRecord);
 995         ok(SUCCEEDED(hr), "Installer_CreateRecord failed, hresult 0x%08x\n", hr);
 996         ok(pRecord != NULL, "Installer_CreateRecord should not have returned NULL record\n");
 997     }
 998     if (pRecord)
 999     {
1000         int iFieldCount = 0;
1001
1002         /* Record::FieldCountGet */
1003         hr = Record_FieldCountGet(pRecord, &iFieldCount);
1004         ok(SUCCEEDED(hr), "Record_FiledCountGet failed, hresult 0x%08x\n", hr);
1005         ok(iFieldCount == 1, "Record_FieldCountGet result was %d but expected 1\n", iFieldCount);
1006
1007         IDispatch_Release(pRecord);
1008     }
1009
1010     /* Prepare package */
1011     create_database(msifile, tables, sizeof(tables) / sizeof(msi_table));
1012
1013     len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, CURR_DIR, -1, szPath, MAX_PATH);
1014     ok(len, "MultiByteToWideChar returned error %d\n", GetLastError());
1015     if (!len) return;
1016
1017     lstrcatW(szPath, szBackslash);
1018     lstrcatW(szPath, szMsifile);
1019
1020     /* Installer::OpenPackage */
1021     hr = Installer_OpenPackage(szPath, 0, &pSession);
1022     ok(SUCCEEDED(hr), "Installer_OpenPackage failed, hresult 0x%08x\n", hr);
1023     if (SUCCEEDED(hr))
1024     {
1025         test_Session(pSession);
1026         IDispatch_Release(pSession);
1027     }
1028
1029     DeleteFileA(msifile);
1030
1031     /* Installer::Version */
1032     todo_wine {
1033         memset(szPath, 0, sizeof(szPath));
1034         hr = Installer_VersionGet(szPath);
1035         ok(SUCCEEDED(hr), "Installer_VersionGet failed, hresult 0x%08x\n", hr);
1036     }
1037 }
1038
1039 START_TEST(automation)
1040 {
1041     DWORD len;
1042     char temp_path[MAX_PATH], prev_path[MAX_PATH];
1043     HRESULT hr;
1044     CLSID clsid;
1045     IUnknown *pUnk;
1046
1047     GetCurrentDirectoryA(MAX_PATH, prev_path);
1048     GetTempPath(MAX_PATH, temp_path);
1049     SetCurrentDirectoryA(temp_path);
1050
1051     lstrcpyA(CURR_DIR, temp_path);
1052     len = lstrlenA(CURR_DIR);
1053
1054     if(len && (CURR_DIR[len - 1] == '\\'))
1055         CURR_DIR[len - 1] = 0;
1056
1057     hr = OleInitialize(NULL);
1058     ok (SUCCEEDED(hr), "OleInitialize returned 0x%08x\n", hr);
1059     hr = CLSIDFromProgID(szProgId, &clsid);
1060     ok (SUCCEEDED(hr), "CLSIDFromProgID returned 0x%08x\n", hr);
1061     hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&pUnk);
1062     ok(SUCCEEDED(hr), "CoCreateInstance returned 0x%08x\n", hr);
1063
1064     if (pUnk)
1065     {
1066         hr = IUnknown_QueryInterface(pUnk, &IID_IDispatch, (void **)&pInstaller);
1067         ok (SUCCEEDED(hr), "IUnknown::QueryInterface returned 0x%08x\n", hr);
1068
1069         test_dispid();
1070         test_dispatch();
1071         test_Installer();
1072
1073         hr = IUnknown_Release(pUnk);
1074         ok (SUCCEEDED(hr), "IUnknown::Release returned 0x%08x\n", hr);
1075     }
1076
1077     OleUninitialize();
1078
1079     SetCurrentDirectoryA(prev_path);
1080 }