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

   1 /*
   2  * Copyright (C) 2005 Mike McCormack for CodeWeavers
   3  *
   4  * A test program for MSI database files.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdio.h>
  21
  22 #include <windows.h>
  23 #include <msi.h>
  24 #include <msiquery.h>
  25
  26 #include "wine/test.h"
  27
  28 static const char *msifile = "winetest.msi";
  29 static const char *msifile2 = "winetst2.msi";
  30 static const char *mstfile = "winetst.mst";
  31
  32 #ifndef ERROR_INSTALL_TRANSFORM_FAILURE
  33 #define ERROR_INSTALL_TRANSFORM_FAILURE 1624
  34 #endif
  35
  36 static void test_msidatabase(void)
  37 {
  38     MSIHANDLE hdb = 0;
  39     UINT res;
  40
  41     DeleteFile(msifile);
  42
  43     /* create an empty database */
  44     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
  45     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  46
  47     res = MsiDatabaseCommit( hdb );
  48     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  49
  50     res = MsiCloseHandle( hdb );
  51     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  52
  53     res = DeleteFile( msifile );
  54     ok( res == TRUE, "Failed to delete database\n" );
  55 }
  56
  57 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
  58 {
  59     MSIHANDLE hview = 0;
  60     UINT r, ret;
  61
  62     /* open a select query */
  63     r = MsiDatabaseOpenView(hdb, query, &hview);
  64     if (r != ERROR_SUCCESS)
  65         return r;
  66     r = MsiViewExecute(hview, 0);
  67     if (r != ERROR_SUCCESS)
  68         return r;
  69     ret = MsiViewFetch(hview, phrec);
  70     r = MsiViewClose(hview);
  71     if (r != ERROR_SUCCESS)
  72         return r;
  73     r = MsiCloseHandle(hview);
  74     if (r != ERROR_SUCCESS)
  75         return r;
  76     return ret;
  77 }
  78
  79 static void test_msiinsert(void)
  80 {
  81     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
  82     UINT r;
  83     const char *query;
  84     char buf[80];
  85     DWORD sz;
  86
  87     DeleteFile(msifile);
  88
  89     /* just MsiOpenDatabase should not create a file */
  90     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
  91     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
  92
  93     /* create a table */
  94     query = "CREATE TABLE `phone` ( "
  95             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
  96             "PRIMARY KEY `id`)";
  97     r = MsiDatabaseOpenView(hdb, query, &hview);
  98     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
  99     r = MsiViewExecute(hview, 0);
 100     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 101     r = MsiViewClose(hview);
 102     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 103     r = MsiCloseHandle(hview);
 104     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 105
 106     /* insert a value into it */
 107     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 108         "VALUES('1', 'Abe', '8675309')";
 109     r = MsiDatabaseOpenView(hdb, query, &hview);
 110     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 111     r = MsiViewExecute(hview, 0);
 112     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 113     r = MsiViewClose(hview);
 114     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 115     r = MsiCloseHandle(hview);
 116     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 117
 118     query = "SELECT * FROM `phone` WHERE `id` = 1";
 119     r = do_query(hdb, query, &hrec);
 120     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 121
 122     /* check the record contains what we put in it */
 123     r = MsiRecordGetFieldCount(hrec);
 124     ok(r == 3, "record count wrong\n");
 125
 126     todo_wine {
 127     r = MsiRecordIsNull(hrec, 0);
 128     ok(r == FALSE, "field 0 not null\n");
 129     }
 130
 131     r = MsiRecordGetInteger(hrec, 1);
 132     ok(r == 1, "field 1 contents wrong\n");
 133     sz = sizeof buf;
 134     r = MsiRecordGetString(hrec, 2, buf, &sz);
 135     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 136     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 137     sz = sizeof buf;
 138     r = MsiRecordGetString(hrec, 3, buf, &sz);
 139     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 140     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 141
 142     r = MsiCloseHandle(hrec);
 143     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 144
 145     /* open a select query */
 146     hrec = 100;
 147     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 148     r = do_query(hdb, query, &hrec);
 149     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 150     ok(hrec == 0, "hrec should be null\n");
 151
 152     r = MsiCloseHandle(hrec);
 153     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 154
 155     query = "SELECT * FROM `phone` WHERE `id` < 0";
 156     r = do_query(hdb, query, &hrec);
 157     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 158
 159     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 160     r = do_query(hdb, query, &hrec);
 161     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 162
 163     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 164     r = do_query(hdb, query, &hrec);
 165     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 166
 167     query = "SELECT * FROM `phone` WHERE `id` > 10";
 168     r = do_query(hdb, query, &hrec);
 169     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 170
 171     /* now try a few bad INSERT xqueries */
 172     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 173         "VALUES(?, ?)";
 174     r = MsiDatabaseOpenView(hdb, query, &hview);
 175     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 176
 177     /* construct a record to insert */
 178     hrec = MsiCreateRecord(4);
 179     r = MsiRecordSetInteger(hrec, 1, 2);
 180     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 181     r = MsiRecordSetString(hrec, 2, "Adam");
 182     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 183     r = MsiRecordSetString(hrec, 3, "96905305");
 184     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 185
 186     /* insert another value, using a record and wildcards */
 187     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 188         "VALUES(?, ?, ?)";
 189     r = MsiDatabaseOpenView(hdb, query, &hview);
 190     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 191
 192     if (r == ERROR_SUCCESS)
 193     {
 194         r = MsiViewExecute(hview, hrec);
 195         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 196         r = MsiViewClose(hview);
 197         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 198         r = MsiCloseHandle(hview);
 199         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 200     }
 201     r = MsiCloseHandle(hrec);
 202     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 203
 204     r = MsiViewFetch(0, NULL);
 205     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 206
 207     r = MsiDatabaseCommit(hdb);
 208     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 209
 210     r = MsiCloseHandle(hdb);
 211     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 212
 213     r = DeleteFile(msifile);
 214     ok(r == TRUE, "file didn't exist after commit\n");
 215 }
 216
 217 typedef UINT (WINAPI *fnMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 218 static fnMsiDecomposeDescriptorA pMsiDecomposeDescriptorA;
 219
 220 static void test_msidecomposedesc(void)
 221 {
 222     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 223     const char *desc;
 224     UINT r;
 225     DWORD len;
 226     HMODULE hmod;
 227
 228     hmod = GetModuleHandle("msi.dll");
 229     if (!hmod)
 230         return;
 231     pMsiDecomposeDescriptorA = (fnMsiDecomposeDescriptorA)
 232         GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 233     if (!pMsiDecomposeDescriptorA)
 234         return;
 235
 236     /* test a valid feature descriptor */
 237     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 238     len = 0;
 239     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 240     ok(r == ERROR_SUCCESS, "returned an error\n");
 241     ok(len == strlen(desc), "length was wrong\n");
 242     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 243     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 244     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 245
 246     /* test an invalid feature descriptor with too many characters */
 247     desc = "']gAVn-}f(ZXfeAR6.ji"
 248            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 249            "3w2x^IGfe?CxI5heAvk.";
 250     len = 0;
 251     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 252     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 253
 254     /*
 255      * Test a valid feature descriptor with the
 256      * maximum number of characters and some trailing characters.
 257      */
 258     desc = "']gAVn-}f(ZXfeAR6.ji"
 259            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 260            "3w2x^IGfe?CxI5heAvk."
 261            "extra";
 262     len = 0;
 263     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 264     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 265     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 266
 267     len = 0;
 268     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 269     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 270     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 271
 272     len = 0;
 273     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 274     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 275     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 276
 277     len = 0;
 278     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 279     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 280     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 281
 282     len = 0;
 283     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 284     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 285     ok(len == 0, "length wrong\n");
 286 }
 287
 288 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 289 {
 290     MSIHANDLE htab = 0;
 291     UINT res;
 292
 293     res = MsiDatabaseOpenView( hdb, szQuery, &htab );
 294     if(res == ERROR_SUCCESS )
 295     {
 296         UINT r;
 297
 298         r = MsiViewExecute( htab, hrec );
 299         if(r != ERROR_SUCCESS )
 300             res = r;
 301
 302         r = MsiViewClose( htab );
 303         if(r != ERROR_SUCCESS )
 304             res = r;
 305
 306         r = MsiCloseHandle( htab );
 307         if(r != ERROR_SUCCESS )
 308             res = r;
 309     }
 310     return res;
 311 }
 312
 313 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 314 {
 315     return try_query_param( hdb, szQuery, 0 );
 316 }
 317
 318 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 319 {
 320     MSIHANDLE hrec = 0;
 321     UINT r;
 322
 323     hrec = MsiCreateRecord( 1 );
 324     MsiRecordSetString( hrec, 1, "Hello");
 325
 326     r = try_query_param( hdb, szQuery, hrec );
 327
 328     MsiCloseHandle( hrec );
 329     return r;
 330 }
 331
 332 static void test_msibadqueries(void)
 333 {
 334     MSIHANDLE hdb = 0;
 335     UINT r;
 336
 337     DeleteFile(msifile);
 338
 339     /* just MsiOpenDatabase should not create a file */
 340     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 341     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 342
 343     r = MsiDatabaseCommit( hdb );
 344     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 345
 346     r = MsiCloseHandle( hdb );
 347     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 348
 349     /* open it readonly */
 350     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb );
 351     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 352
 353     /* add a table to it */
 354     r = try_query( hdb, "select * from _Tables");
 355     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 356
 357     r = MsiCloseHandle( hdb );
 358     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 359
 360     /* open it read/write */
 361     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
 362     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 363
 364     /* a bunch of test queries that fail with the native MSI */
 365
 366     r = try_query( hdb, "CREATE TABLE");
 367     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 368
 369     r = try_query( hdb, "CREATE TABLE `a`");
 370     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 371
 372     r = try_query( hdb, "CREATE TABLE `a` ()");
 373     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 374
 375     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 376     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 377
 378     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 379     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 380
 381     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 382     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 383
 384     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 385     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 386
 387     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 388     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 389
 390     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 391     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 392
 393     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 394     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 395
 396     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 397     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 398
 399     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 400     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 401
 402     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 403     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 404
 405     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 406     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 407
 408     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 409     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 410
 411     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 412     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 413
 414     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 415     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 416
 417     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 418     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 419
 420     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 421     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 422
 423     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 424           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 425     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 426
 427     r = MsiDatabaseCommit( hdb );
 428     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 429
 430     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 431                           "PRIMARY KEY `foo`)");
 432     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 433
 434     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 435     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 436
 437     r = MsiDatabaseCommit( hdb );
 438     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 439
 440     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 441                           "PRIMARY KEY `ba`)");
 442     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 443
 444     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 445     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 446
 447     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 448                           "PRIMARY KEY `t`)");
 449     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 450
 451     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 452     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 453
 454     r = MsiCloseHandle( hdb );
 455     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 456
 457     r = DeleteFile( msifile );
 458     ok(r == TRUE, "file didn't exist after commit\n");
 459 }
 460
 461 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 462 {
 463     MSIHANDLE hview = 0;
 464     UINT r;
 465
 466     r = MsiDatabaseOpenView(hdb, query, &hview);
 467     if( r != ERROR_SUCCESS )
 468         return r;
 469
 470     r = MsiViewExecute(hview, hrec);
 471     if( r == ERROR_SUCCESS )
 472         r = MsiViewClose(hview);
 473     MsiCloseHandle(hview);
 474     return r;
 475 }
 476
 477 static void test_viewmodify(void)
 478 {
 479     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 480     UINT r;
 481     const char *query;
 482     char buffer[0x100];
 483     DWORD sz;
 484
 485     DeleteFile(msifile);
 486
 487     /* just MsiOpenDatabase should not create a file */
 488     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 489     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 490
 491     query = "CREATE TABLE `phone` ( "
 492             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 493             "PRIMARY KEY `id`)";
 494     r = run_query( hdb, 0, query );
 495     ok(r == ERROR_SUCCESS, "query failed\n");
 496
 497     /* check what the error function reports without doing anything */
 498     sz = 0;
 499     /* passing NULL as the 3rd param make function to crash on older platforms */
 500     r = MsiViewGetError( 0, NULL, &sz );
 501     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 502
 503     /* open a view */
 504     query = "SELECT * FROM `phone`";
 505     r = MsiDatabaseOpenView(hdb, query, &hview);
 506     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 507
 508     /* see what happens with a good hview and bad args */
 509     r = MsiViewGetError( hview, NULL, NULL );
 510     ok(r == MSIDBERROR_INVALIDARG || r == MSIDBERROR_NOERROR,
 511        "MsiViewGetError returns %u (expected -3)\n", r);
 512     r = MsiViewGetError( hview, buffer, NULL );
 513     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 514
 515     /* see what happens with a zero length buffer */
 516     sz = 0;
 517     buffer[0] = 'x';
 518     r = MsiViewGetError( hview, buffer, &sz );
 519     ok(r == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 520     ok(buffer[0] == 'x', "buffer cleared\n");
 521     ok(sz == 0, "size not zero\n");
 522
 523     /* ok this one is strange */
 524     sz = 0;
 525     r = MsiViewGetError( hview, NULL, &sz );
 526     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 527     ok(sz == 0, "size not zero\n");
 528
 529     /* see if it really has an error */
 530     sz = sizeof buffer;
 531     buffer[0] = 'x';
 532     r = MsiViewGetError( hview, buffer, &sz );
 533     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 534     ok(buffer[0] == 0, "buffer not cleared\n");
 535     ok(sz == 0, "size not zero\n");
 536
 537     r = MsiViewExecute(hview, 0);
 538     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 539
 540     /* try some invalid records */
 541     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 542     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 543     r = MsiViewModify(hview, -1, 0 );
 544     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 545
 546     /* try an small record */
 547     hrec = MsiCreateRecord(1);
 548     r = MsiViewModify(hview, -1, hrec );
 549     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 550
 551     r = MsiCloseHandle(hrec);
 552     ok(r == ERROR_SUCCESS, "failed to close record\n");
 553
 554     /* insert a valid record */
 555     hrec = MsiCreateRecord(3);
 556
 557     r = MsiRecordSetInteger(hrec, 2, 1);
 558     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 559     r = MsiRecordSetString(hrec, 2, "bob");
 560     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 561     r = MsiRecordSetString(hrec, 3, "7654321");
 562     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 563
 564     r = MsiViewExecute(hview, 0);
 565     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 566     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 567     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 568
 569     /* insert the same thing again */
 570     r = MsiViewExecute(hview, 0);
 571     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 572
 573     /* should fail ... */
 574     todo_wine {
 575     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 576     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 577     }
 578
 579     r = MsiCloseHandle(hrec);
 580     ok(r == ERROR_SUCCESS, "failed to close record\n");
 581
 582     r = MsiViewClose(hview);
 583     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 584     r = MsiCloseHandle(hview);
 585     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 586
 587     r = MsiCloseHandle( hdb );
 588     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
 589 }
 590
 591 static MSIHANDLE create_db(void)
 592 {
 593     MSIHANDLE hdb = 0;
 594     UINT res;
 595
 596     DeleteFile(msifile);
 597
 598     /* create an empty database */
 599     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
 600     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
 601     if( res != ERROR_SUCCESS )
 602         return hdb;
 603
 604     res = MsiDatabaseCommit( hdb );
 605     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 606
 607     return hdb;
 608 }
 609
 610 static void test_getcolinfo(void)
 611 {
 612     MSIHANDLE hdb, hview = 0, rec = 0;
 613     UINT r;
 614     DWORD sz;
 615     char buffer[0x20];
 616
 617     /* create an empty db */
 618     hdb = create_db();
 619     ok( hdb, "failed to create db\n");
 620
 621     /* tables should be present */
 622     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
 623     ok( r == ERROR_SUCCESS, "failed to open query\n");
 624
 625     r = MsiViewExecute(hview, 0);
 626     ok( r == ERROR_SUCCESS, "failed to execute query\n");
 627
 628     /* check that NAMES works */
 629     rec = 0;
 630     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
 631     ok( r == ERROR_SUCCESS, "failed to get names\n");
 632     sz = sizeof buffer;
 633     r = MsiRecordGetString(rec, 1, buffer, &sz );
 634     ok( r == ERROR_SUCCESS, "failed to get string\n");
 635     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
 636     r = MsiCloseHandle( rec );
 637     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 638
 639     /* check that TYPES works */
 640     rec = 0;
 641     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
 642     ok( r == ERROR_SUCCESS, "failed to get names\n");
 643     sz = sizeof buffer;
 644     r = MsiRecordGetString(rec, 1, buffer, &sz );
 645     ok( r == ERROR_SUCCESS, "failed to get string\n");
 646     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
 647     r = MsiCloseHandle( rec );
 648     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 649
 650     /* check that invalid values fail */
 651     rec = 0;
 652     r = MsiViewGetColumnInfo( hview, 100, &rec );
 653     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 654     ok( rec == 0, "returned a record\n");
 655
 656     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
 657     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 658
 659     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
 660     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
 661
 662     r = MsiViewClose(hview);
 663     ok( r == ERROR_SUCCESS, "failed to close view\n");
 664     r = MsiCloseHandle(hview);
 665     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
 666     r = MsiCloseHandle(hdb);
 667     ok( r == ERROR_SUCCESS, "failed to close database\n");
 668 }
 669
 670 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
 671 {
 672     MSIHANDLE hview = 0, rec = 0;
 673     UINT r;
 674
 675     r = MsiDatabaseOpenView(hdb, query, &hview);
 676     if( r != ERROR_SUCCESS )
 677         return r;
 678
 679     r = MsiViewExecute(hview, 0);
 680     if( r == ERROR_SUCCESS )
 681     {
 682         MsiViewGetColumnInfo( hview, type, &rec );
 683         MsiViewClose(hview);
 684     }
 685     MsiCloseHandle(hview);
 686     return rec;
 687 }
 688
 689 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
 690 {
 691     MSIHANDLE hview = 0, rec = 0;
 692     UINT r, type = 0;
 693     char query[0x100];
 694
 695     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
 696
 697     r = MsiDatabaseOpenView(hdb, query, &hview);
 698     if( r != ERROR_SUCCESS )
 699         return r;
 700
 701     r = MsiViewExecute(hview, 0);
 702     if( r == ERROR_SUCCESS )
 703     {
 704         while (1)
 705         {
 706             r = MsiViewFetch( hview, &rec );
 707             if( r != ERROR_SUCCESS)
 708                 break;
 709             r = MsiRecordGetInteger( rec, 2 );
 710             if (r == field)
 711                 type = MsiRecordGetInteger( rec, 4 );
 712             MsiCloseHandle( rec );
 713         }
 714
 715         MsiViewClose(hview);
 716     }
 717     MsiCloseHandle(hview);
 718     return type;
 719 }
 720
 721 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
 722 {
 723     CHAR buffer[0x20];
 724     UINT r;
 725     DWORD sz;
 726
 727     sz = sizeof buffer;
 728     r = MsiRecordGetString( rec, field, buffer, &sz );
 729     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
 730 }
 731
 732 static void test_viewgetcolumninfo(void)
 733 {
 734     MSIHANDLE hdb = 0, rec;
 735     UINT r;
 736
 737     hdb = create_db();
 738     ok( hdb, "failed to create db\n");
 739
 740     r = run_query( hdb, 0,
 741             "CREATE TABLE `Properties` "
 742             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
 743     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 744
 745     /* check the column types */
 746     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
 747     ok( rec, "failed to get column info record\n" );
 748
 749     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 750     ok( check_record( rec, 2, "S1"), "wrong record type\n");
 751
 752     MsiCloseHandle( rec );
 753
 754     /* check the type in _Columns */
 755     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
 756     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
 757
 758     /* now try the names */
 759     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
 760     ok( rec, "failed to get column info record\n" );
 761
 762     ok( check_record( rec, 1, "Property"), "wrong record type\n");
 763     ok( check_record( rec, 2, "Value"), "wrong record type\n");
 764
 765     MsiCloseHandle( rec );
 766
 767     r = run_query( hdb, 0,
 768             "CREATE TABLE `Binary` "
 769             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
 770     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 771
 772     /* check the column types */
 773     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
 774     ok( rec, "failed to get column info record\n" );
 775
 776     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 777     ok( check_record( rec, 2, "V0"), "wrong record type\n");
 778
 779     MsiCloseHandle( rec );
 780
 781     /* check the type in _Columns */
 782     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
 783     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
 784
 785     /* now try the names */
 786     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
 787     ok( rec, "failed to get column info record\n" );
 788
 789     ok( check_record( rec, 1, "Name"), "wrong record type\n");
 790     ok( check_record( rec, 2, "Data"), "wrong record type\n");
 791     MsiCloseHandle( rec );
 792
 793     r = run_query( hdb, 0,
 794             "CREATE TABLE `UIText` "
 795             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
 796     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 797
 798     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
 799     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
 800
 801     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
 802     ok( rec, "failed to get column info record\n" );
 803     ok( check_record( rec, 1, "Key"), "wrong record type\n");
 804     ok( check_record( rec, 2, "Text"), "wrong record type\n");
 805     MsiCloseHandle( rec );
 806
 807     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
 808     ok( rec, "failed to get column info record\n" );
 809     ok( check_record( rec, 1, "s72"), "wrong record type\n");
 810     ok( check_record( rec, 2, "L255"), "wrong record type\n");
 811     MsiCloseHandle( rec );
 812
 813     MsiCloseHandle( hdb );
 814 }
 815
 816 static void test_msiexport(void)
 817 {
 818     MSIHANDLE hdb = 0, hview = 0;
 819     UINT r;
 820     const char *query;
 821     char path[MAX_PATH];
 822     const char file[] = "phone.txt";
 823     HANDLE handle;
 824     char buffer[0x100];
 825     DWORD length;
 826     const char expected[] =
 827         "id\tname\tnumber\r\n"
 828         "I2\tS32\tS32\r\n"
 829         "phone\tid\r\n"
 830         "1\tAbe\t8675309\r\n";
 831
 832     DeleteFile(msifile);
 833
 834     /* just MsiOpenDatabase should not create a file */
 835     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 836     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 837
 838     /* create a table */
 839     query = "CREATE TABLE `phone` ( "
 840             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 841             "PRIMARY KEY `id`)";
 842     r = MsiDatabaseOpenView(hdb, query, &hview);
 843     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 844     r = MsiViewExecute(hview, 0);
 845     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 846     r = MsiViewClose(hview);
 847     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 848     r = MsiCloseHandle(hview);
 849     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 850
 851     /* insert a value into it */
 852     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 853         "VALUES('1', 'Abe', '8675309')";
 854     r = MsiDatabaseOpenView(hdb, query, &hview);
 855     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 856     r = MsiViewExecute(hview, 0);
 857     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 858     r = MsiViewClose(hview);
 859     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 860     r = MsiCloseHandle(hview);
 861     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 862
 863     GetCurrentDirectory(MAX_PATH, path);
 864
 865     r = MsiDatabaseExport(hdb, "phone", path, file);
 866     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
 867
 868     MsiCloseHandle(hdb);
 869
 870     lstrcat(path, "\\");
 871     lstrcat(path, file);
 872
 873     /* check the data that was written */
 874     length = 0;
 875     memset(buffer, 0, sizeof buffer);
 876     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
 877     if (handle != INVALID_HANDLE_VALUE)
 878     {
 879         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
 880         CloseHandle(handle);
 881         DeleteFile(path);
 882     }
 883     else
 884         ok(0, "failed to open file %s\n", path);
 885
 886     ok( length == strlen(expected), "length of data wrong\n");
 887     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
 888     DeleteFile(msifile);
 889 }
 890
 891 static void test_longstrings(void)
 892 {
 893     const char insert_query[] =
 894         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
 895     char *str;
 896     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 897     DWORD len;
 898     UINT r;
 899     const DWORD STRING_LENGTH = 0x10005;
 900
 901     DeleteFile(msifile);
 902     /* just MsiOpenDatabase should not create a file */
 903     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 904     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 905
 906     /* create a table */
 907     r = try_query( hdb,
 908         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
 909     ok(r == ERROR_SUCCESS, "query failed\n");
 910
 911     /* try a insert a very long string */
 912     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
 913     len = strchr(insert_query, 'Z') - insert_query;
 914     strcpy(str, insert_query);
 915     memset(str+len, 'Z', STRING_LENGTH);
 916     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
 917     r = try_query( hdb, str );
 918     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 919
 920     HeapFree(GetProcessHeap(), 0, str);
 921
 922     MsiDatabaseCommit(hdb);
 923     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 924     MsiCloseHandle(hdb);
 925
 926     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
 927     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 928
 929     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
 930     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 931
 932     r = MsiViewExecute(hview, 0);
 933     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 934
 935     r = MsiViewFetch(hview, &hrec);
 936     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 937
 938     MsiCloseHandle(hview);
 939
 940     r = MsiRecordGetString(hrec, 2, NULL, &len);
 941     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 942     ok(len == STRING_LENGTH, "string length wrong\n");
 943
 944     MsiCloseHandle(hrec);
 945     MsiCloseHandle(hdb);
 946     DeleteFile(msifile);
 947 }
 948
 949 static void create_file(const CHAR *name)
 950 {
 951     HANDLE file;
 952     DWORD written;
 953
 954     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 955     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
 956     WriteFile(file, name, strlen(name), &written, NULL);
 957     WriteFile(file, "\n", strlen("\n"), &written, NULL);
 958     CloseHandle(file);
 959 }
 960
 961 static void test_streamtable(void)
 962 {
 963     MSIHANDLE hdb = 0, rec, view;
 964     char file[MAX_PATH];
 965     char buf[MAX_PATH];
 966     DWORD size;
 967     UINT r;
 968
 969     hdb = create_db();
 970     ok( hdb, "failed to create db\n");
 971
 972     r = run_query( hdb, 0,
 973             "CREATE TABLE `Properties` "
 974             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
 975     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 976
 977     /* check the column types */
 978     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
 979     ok( rec, "failed to get column info record\n" );
 980
 981     todo_wine {
 982     ok( check_record( rec, 1, "s62"), "wrong record type\n");
 983     ok( check_record( rec, 2, "V0"), "wrong record type\n");
 984     }
 985
 986     MsiCloseHandle( rec );
 987
 988     /* now try the names */
 989     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
 990     ok( rec, "failed to get column info record\n" );
 991
 992     todo_wine {
 993     ok( check_record( rec, 1, "Name"), "wrong record type\n");
 994     ok( check_record( rec, 2, "Data"), "wrong record type\n");
 995     }
 996
 997     MsiCloseHandle( rec );
 998
 999     /* insert a file into the _Streams table */
1000     create_file( "test.txt" );
1001
1002     rec = MsiCreateRecord( 2 );
1003     MsiRecordSetString( rec, 1, "data" );
1004
1005     r = MsiRecordSetStream( rec, 2, "test.txt" );
1006     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1007
1008     DeleteFile("test.txt");
1009
1010     r = MsiDatabaseOpenView( hdb,
1011             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1012     todo_wine
1013     {
1014         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1015     }
1016
1017     r = MsiViewExecute( view, rec );
1018     todo_wine
1019     {
1020         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1021     }
1022
1023     MsiCloseHandle( rec );
1024     MsiCloseHandle( view );
1025
1026     r = MsiDatabaseOpenView( hdb,
1027             "SELECT `Name`, `Data` FROM `_Streams`", &view );
1028     todo_wine
1029     {
1030         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1031     }
1032
1033     r = MsiViewExecute( view, 0 );
1034     todo_wine
1035     {
1036         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1037     }
1038
1039     r = MsiViewFetch( view, &rec );
1040     todo_wine
1041     {
1042         ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1043     }
1044
1045     size = MAX_PATH;
1046     r = MsiRecordGetString( rec, 1, file, &size );
1047     todo_wine
1048     {
1049         ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1050         ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1051     }
1052
1053     size = MAX_PATH;
1054     memset(buf, 0, MAX_PATH);
1055     r = MsiRecordReadStream( rec, 2, buf, &size );
1056     todo_wine
1057     {
1058         ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1059         ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1060     }
1061
1062     MsiCloseHandle( rec );
1063
1064     r = MsiViewFetch( view, &rec );
1065     todo_wine
1066     {
1067         ok( r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1068     }
1069
1070     MsiCloseHandle( view );
1071     MsiCloseHandle( hdb );
1072     DeleteFile(msifile);
1073 }
1074
1075 static void test_where(void)
1076 {
1077     MSIHANDLE hdb = 0, rec;
1078     LPCSTR query;
1079     UINT r;
1080
1081     hdb = create_db();
1082     ok( hdb, "failed to create db\n");
1083
1084     r = run_query( hdb, 0,
1085             "CREATE TABLE `Media` ("
1086             "`DiskId` SHORT NOT NULL, "
1087             "`LastSequence` LONG, "
1088             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1089             "`Cabinet` CHAR(255), "
1090             "`VolumeLabel` CHAR(32), "
1091             "`Source` CHAR(72) "
1092             "PRIMARY KEY `DiskId`)" );
1093     ok( r == S_OK, "cannot create Media table: %d\n", r );
1094
1095     r = run_query( hdb, 0, "INSERT INTO `Media` "
1096             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1097             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1098     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1099
1100     r = run_query( hdb, 0, "INSERT INTO `Media` "
1101             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1102             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1103     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1104
1105     r = run_query( hdb, 0, "INSERT INTO `Media` "
1106             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1107             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1108     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1109
1110     query = "SELECT * FROM `Media`";
1111     r = do_query(hdb, query, &rec);
1112     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1113     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1114     MsiCloseHandle( rec );
1115
1116     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1117     r = do_query(hdb, query, &rec);
1118     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1119     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1120
1121     r = MsiRecordGetInteger(rec, 1);
1122     ok( 2 == r, "field wrong\n");
1123     r = MsiRecordGetInteger(rec, 2);
1124     ok( 1 == r, "field wrong\n");
1125
1126     MsiCloseHandle( rec );
1127
1128     MsiCloseHandle( hdb );
1129     DeleteFile(msifile);
1130 }
1131
1132 static CHAR CURR_DIR[MAX_PATH];
1133
1134 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1135                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1136                                 "TestTable\tFirstPrimaryColumn\n"
1137                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1138
1139 static void write_file(const CHAR *filename, const char *data, int data_size)
1140 {
1141     DWORD size;
1142
1143     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1144                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1145
1146     WriteFile(hf, data, data_size, &size, NULL);
1147     CloseHandle(hf);
1148 }
1149
1150 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1151 {
1152     UINT r;
1153
1154     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1155     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1156     DeleteFileA("temp_file");
1157
1158     return r;
1159 }
1160
1161 static void test_msiimport(void)
1162 {
1163     MSIHANDLE hdb, view, rec;
1164     LPCSTR query;
1165     UINT r, count;
1166     signed int i;
1167
1168     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1169
1170     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1171     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1172
1173     r = add_table_to_db(hdb, test_data);
1174     todo_wine
1175     {
1176         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1177     }
1178
1179     query = "SELECT * FROM `TestTable`";
1180     r = MsiDatabaseOpenView(hdb, query, &view);
1181     todo_wine
1182     {
1183         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1184     }
1185
1186     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1187     count = MsiRecordGetFieldCount(rec);
1188     todo_wine
1189     {
1190         ok(count == 9, "Expected 9, got %d\n", count);
1191         ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1192         ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1193         ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1194         ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1195         ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1196         ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1197         ok(check_record(rec, 7, "String"), "Expected String\n");
1198         ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1199         ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1200     }
1201
1202     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1203     count = MsiRecordGetFieldCount(rec);
1204     todo_wine
1205     {
1206         ok(count == 9, "Expected 9, got %d\n", count);
1207         ok(check_record(rec, 1, "s255"), "Expected s255\n");
1208         ok(check_record(rec, 2, "i2"), "Expected i2\n");
1209         ok(check_record(rec, 3, "i2"), "Expected i2\n");
1210         ok(check_record(rec, 4, "I2"), "Expected I2\n");
1211         ok(check_record(rec, 5, "i4"), "Expected i4\n");
1212         ok(check_record(rec, 6, "I4"), "Expected I4\n");
1213         ok(check_record(rec, 7, "S255"), "Expected S255\n");
1214         ok(check_record(rec, 8, "S0"), "Expected S0\n");
1215         ok(check_record(rec, 9, "s0"), "Expected s0\n");
1216     }
1217
1218     query = "SELECT * FROM `TestTable`";
1219     r = do_query(hdb, query, &rec);
1220     todo_wine
1221     {
1222         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1223     }
1224
1225     todo_wine
1226     {
1227         ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1228         ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1229         ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1230         ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1231     }
1232
1233     i = MsiRecordGetInteger(rec, 2);
1234     todo_wine
1235     {
1236         ok(i == 5, "Expected 5, got %d\n", i);
1237     }
1238
1239     i = MsiRecordGetInteger(rec, 3);
1240     todo_wine
1241     {
1242         ok(i == 2, "Expected 2, got %d\n", i);
1243     }
1244
1245     i = MsiRecordGetInteger(rec, 4);
1246     ok(i == 0x80000000, "Expected 0x80000000, got %d\n", i);
1247
1248     i = MsiRecordGetInteger(rec, 5);
1249     todo_wine
1250     {
1251         ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1252     }
1253
1254     i = MsiRecordGetInteger(rec, 6);
1255     todo_wine
1256     {
1257         ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1258     }
1259
1260     MsiCloseHandle(rec);
1261     MsiCloseHandle(view);
1262     MsiCloseHandle(hdb);
1263     DeleteFileA(msifile);
1264 }
1265
1266 static void test_markers(void)
1267 {
1268     MSIHANDLE hdb, rec;
1269     LPCSTR query;
1270     UINT r;
1271
1272     hdb = create_db();
1273     ok( hdb, "failed to create db\n");
1274
1275     rec = MsiCreateRecord(3);
1276     MsiRecordSetString(rec, 1, "Table");
1277     MsiRecordSetString(rec, 2, "Apples");
1278     MsiRecordSetString(rec, 3, "Oranges");
1279
1280     /* try a legit create */
1281     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1282     r = run_query(hdb, 0, query);
1283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1284     MsiCloseHandle(rec);
1285
1286     /* try table name as marker */
1287     rec = MsiCreateRecord(1);
1288     MsiRecordSetString(rec, 1, "Fable");
1289     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1290     r = run_query(hdb, rec, query);
1291     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1292
1293     /* verify that we just created a table called '?', not 'Fable' */
1294     r = try_query(hdb, "SELECT * from `Fable`");
1295     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1296
1297     r = try_query(hdb, "SELECT * from `?`");
1298     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1299
1300     /* try table name as marker without backticks */
1301     MsiRecordSetString(rec, 1, "Mable");
1302     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1303     r = run_query(hdb, rec, query);
1304     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1305
1306     /* try one column name as marker */
1307     MsiRecordSetString(rec, 1, "One");
1308     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1309     r = run_query(hdb, rec, query);
1310     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1311
1312     /* try column names as markers */
1313     MsiCloseHandle(rec);
1314     rec = MsiCreateRecord(2);
1315     MsiRecordSetString(rec, 1, "One");
1316     MsiRecordSetString(rec, 2, "Two");
1317     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1318     r = run_query(hdb, rec, query);
1319     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1320
1321     /* try names with backticks */
1322     MsiCloseHandle(rec);
1323     rec = MsiCreateRecord(3);
1324     MsiRecordSetString(rec, 1, "One");
1325     MsiRecordSetString(rec, 2, "Two");
1326     MsiRecordSetString(rec, 3, "One");
1327     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1328     r = run_query(hdb, rec, query);
1329     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1330
1331     /* try names with backticks, minus definitions */
1332     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1333     r = run_query(hdb, rec, query);
1334     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1335
1336     /* try names without backticks */
1337     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1338     r = run_query(hdb, rec, query);
1339     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1340
1341     /* try one long marker */
1342     MsiCloseHandle(rec);
1343     rec = MsiCreateRecord(1);
1344     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1345     query = "CREATE TABLE `Mable` ( ? )";
1346     r = run_query(hdb, rec, query);
1347     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1348
1349     /* try all names as markers */
1350     MsiCloseHandle(rec);
1351     rec = MsiCreateRecord(4);
1352     MsiRecordSetString(rec, 1, "Mable");
1353     MsiRecordSetString(rec, 2, "One");
1354     MsiRecordSetString(rec, 3, "Two");
1355     MsiRecordSetString(rec, 4, "One");
1356     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1357     r = run_query(hdb, rec, query);
1358     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1359
1360     /* try a legit insert */
1361     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1362     r = run_query(hdb, 0, query);
1363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1364
1365     r = try_query(hdb, "SELECT * from `Table`");
1366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1367
1368     /* try values as markers */
1369     MsiCloseHandle(rec);
1370     rec = MsiCreateRecord(2);
1371     MsiRecordSetInteger(rec, 1, 4);
1372     MsiRecordSetString(rec, 2, "hi");
1373     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1374     r = run_query(hdb, rec, query);
1375     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1376
1377     /* try column names and values as markers */
1378     MsiCloseHandle(rec);
1379     rec = MsiCreateRecord(4);
1380     MsiRecordSetString(rec, 1, "One");
1381     MsiRecordSetString(rec, 2, "Two");
1382     MsiRecordSetInteger(rec, 3, 5);
1383     MsiRecordSetString(rec, 4, "hi");
1384     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1385     r = run_query(hdb, rec, query);
1386     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1387
1388     /* try column names as markers */
1389     MsiCloseHandle(rec);
1390     rec = MsiCreateRecord(2);
1391     MsiRecordSetString(rec, 1, "One");
1392     MsiRecordSetString(rec, 2, "Two");
1393     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1394     r = run_query(hdb, rec, query);
1395     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1396
1397     /* try table name as a marker */
1398     MsiCloseHandle(rec);
1399     rec = MsiCreateRecord(1);
1400     MsiRecordSetString(rec, 1, "Table");
1401     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1402     r = run_query(hdb, rec, query);
1403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1404
1405     /* try table name and values as markers */
1406     MsiCloseHandle(rec);
1407     rec = MsiCreateRecord(3);
1408     MsiRecordSetString(rec, 1, "Table");
1409     MsiRecordSetInteger(rec, 2, 10);
1410     MsiRecordSetString(rec, 3, "haha");
1411     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1412     r = run_query(hdb, rec, query);
1413     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1414
1415     /* try all markers */
1416     MsiCloseHandle(rec);
1417     rec = MsiCreateRecord(5);
1418     MsiRecordSetString(rec, 1, "Table");
1419     MsiRecordSetString(rec, 1, "One");
1420     MsiRecordSetString(rec, 1, "Two");
1421     MsiRecordSetInteger(rec, 2, 10);
1422     MsiRecordSetString(rec, 3, "haha");
1423     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1424     r = run_query(hdb, rec, query);
1425     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1426
1427     /* insert an integer as a string */
1428     MsiCloseHandle(rec);
1429     rec = MsiCreateRecord(2);
1430     MsiRecordSetString(rec, 1, "11");
1431     MsiRecordSetString(rec, 2, "hi");
1432     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1433     r = run_query(hdb, rec, query);
1434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1435
1436     /* leave off the '' for the string */
1437     MsiCloseHandle(rec);
1438     rec = MsiCreateRecord(2);
1439     MsiRecordSetInteger(rec, 1, 12);
1440     MsiRecordSetString(rec, 2, "hi");
1441     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
1442     r = run_query(hdb, rec, query);
1443     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1444     MsiCloseHandle(rec);
1445
1446     MsiCloseHandle(hdb);
1447     DeleteFileA(msifile);
1448 }
1449
1450 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
1451 static void test_handle_limit(void)
1452 {
1453     int i;
1454     MSIHANDLE hdb;
1455     MSIHANDLE hviews[MY_NVIEWS];
1456     UINT r;
1457
1458     /* create an empty db */
1459     hdb = create_db();
1460     ok( hdb, "failed to create db\n");
1461
1462     memset(hviews, 0, sizeof(hviews));
1463
1464     for (i=0; i<MY_NVIEWS; i++) {
1465         static char szQueryBuf[256] = "SELECT * from `_Tables`";
1466         hviews[i] = 0xdeadbeeb;
1467         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
1468         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
1469             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
1470             break;
1471     }
1472
1473     ok( i == MY_NVIEWS, "problem opening views\n");
1474
1475     for (i=0; i<MY_NVIEWS; i++) {
1476         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
1477             r = MsiCloseHandle(hviews[i]);
1478             if (r != ERROR_SUCCESS)
1479                 break;
1480         }
1481     }
1482
1483     ok( i == MY_NVIEWS, "problem closing views\n");
1484
1485     r = MsiCloseHandle(hdb);
1486     ok( r == ERROR_SUCCESS, "failed to close database\n");
1487 }
1488
1489 static void test_generate_transform(void)
1490 {
1491     MSIHANDLE hdb1, hdb2;
1492     LPCSTR query;
1493     UINT r;
1494
1495     DeleteFile(msifile);
1496     DeleteFile(msifile2);
1497     DeleteFile(mstfile);
1498
1499     /* create an empty database */
1500     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb1 );
1501     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1502
1503     r = MsiDatabaseCommit( hdb1 );
1504     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1505
1506     /* create another empty database */
1507     r = MsiOpenDatabase(msifile2, MSIDBOPEN_CREATE, &hdb2 );
1508     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1509
1510     r = MsiDatabaseCommit( hdb2 );
1511     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1512
1513     /* the transform between two empty database should be empty */
1514     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1515     todo_wine {
1516     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
1517     }
1518
1519     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
1520     r = run_query(hdb1, 0, query);
1521     ok(r == ERROR_SUCCESS, "failed to add table\n");
1522
1523     todo_wine {
1524     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1525     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1526
1527     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
1528     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1529
1530     MsiCloseHandle( hdb1 );
1531
1532     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1533     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1534
1535     /* apply the same transform again? */
1536     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1537     ok( r == ERROR_INSTALL_TRANSFORM_FAILURE,
1538        "return code %d, should be ERROR_INSTALL_TRANSFORM_FAILURE\n", r );
1539     }
1540
1541     MsiCloseHandle( hdb2 );
1542
1543     DeleteFile(msifile);
1544     DeleteFile(msifile2);
1545     DeleteFile(mstfile);
1546 }
1547
1548 START_TEST(db)
1549 {
1550     test_msidatabase();
1551     test_msiinsert();
1552     test_msidecomposedesc();
1553     test_msibadqueries();
1554     test_viewmodify();
1555     test_viewgetcolumninfo();
1556     test_getcolinfo();
1557     test_msiexport();
1558     test_longstrings();
1559     test_streamtable();
1560     test_where();
1561     test_msiimport();
1562     test_markers();
1563     test_handle_limit();
1564     test_generate_transform();
1565 }