dlls/oledb32/tests/database.c

   1 /* OLEDB Database tests
   2  *
   3  * Copyright 2012 Alistair Leslie-Hughes
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23 #define CONST_VTABLE
  24 #define DBINITCONSTANTS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "msdadc.h"
  30 #include "msdasc.h"
  31 #include "msdaguid.h"
  32 #include "initguid.h"
  33 #include "oledb.h"
  34 #include "oledberr.h"
  35
  36 #include "wine/test.h"
  37
  38 DEFINE_GUID(CSLID_MSDAER, 0xc8b522cf,0x5cf3,0x11ce,0xad,0xe5,0x00,0xaa,0x00,0x44,0x77,0x3d);
  39
  40 static WCHAR initstring_default[] = {'D','a','t','a',' ','S','o','u','r','c','e','=','d','u','m','m','y',';',0};
  41
  42 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
  43 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
  44 {
  45     ULONG rc = IUnknown_AddRef(obj);
  46     IUnknown_Release(obj);
  47     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
  48 }
  49
  50 static void test_GetDataSource(WCHAR *initstring)
  51 {
  52     IDataInitialize *datainit = NULL;
  53     IDBInitialize *dbinit = NULL;
  54     HRESULT hr;
  55
  56     trace("Data Source: %s\n", wine_dbgstr_w(initstring));
  57
  58     hr = CoCreateInstance(&CLSID_MSDAINITIALIZE, NULL, CLSCTX_INPROC_SERVER, &IID_IDataInitialize,(void**)&datainit);
  59     ok(hr == S_OK, "got %08x\n", hr);
  60
  61     EXPECT_REF(datainit, 1);
  62
  63     /* a failure to create data source here may indicate provider is simply not present */
  64     hr = IDataInitialize_GetDataSource(datainit, NULL, CLSCTX_INPROC_SERVER, initstring, &IID_IDBInitialize, (IUnknown**)&dbinit);
  65     if(SUCCEEDED(hr))
  66     {
  67         IDBProperties *props = NULL;
  68
  69         EXPECT_REF(datainit, 1);
  70         EXPECT_REF(dbinit, 1);
  71
  72         hr = IDBInitialize_QueryInterface(dbinit, &IID_IDBProperties, (void**)&props);
  73         ok(hr == S_OK, "got %08x\n", hr);
  74         if(SUCCEEDED(hr))
  75         {
  76             ULONG cnt;
  77             DBPROPINFOSET *pInfoset;
  78             OLECHAR *ary;
  79
  80             EXPECT_REF(dbinit, 2);
  81             EXPECT_REF(props, 2);
  82             hr = IDBProperties_GetPropertyInfo(props, 0, NULL, &cnt, &pInfoset, &ary);
  83             todo_wine ok(hr == S_OK, "got %08x\n", hr);
  84             if(hr == S_OK)
  85             {
  86                 ULONG i;
  87                 for(i =0; i < pInfoset->cPropertyInfos; i++)
  88                 {
  89                     trace("(0x%04x) '%s' %d\n", pInfoset->rgPropertyInfos[i].dwPropertyID, wine_dbgstr_w(pInfoset->rgPropertyInfos[i].pwszDescription),
  90                                              pInfoset->rgPropertyInfos[i].vtType);
  91                 }
  92
  93                 CoTaskMemFree(pInfoset);
  94                 CoTaskMemFree(ary);
  95             }
  96
  97             IDBProperties_Release(props);
  98         }
  99
 100         EXPECT_REF(dbinit, 1);
 101         IDBInitialize_Release(dbinit);
 102     }
 103
 104     EXPECT_REF(datainit, 1);
 105     IDataInitialize_Release(datainit);
 106 }
 107
 108 /* IDBProperties stub */
 109 static HRESULT WINAPI dbprops_QI(IDBProperties *iface, REFIID riid, void **obj)
 110 {
 111     if (IsEqualIID(riid, &IID_IDBProperties) || IsEqualIID(riid, &IID_IUnknown)) {
 112         *obj = iface;
 113         IDBProperties_AddRef(iface);
 114         return S_OK;
 115     }
 116
 117     *obj = NULL;
 118     return E_NOINTERFACE;
 119 }
 120
 121 static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
 122 {
 123     return 2;
 124 }
 125
 126 static ULONG WINAPI dbprops_Release(IDBProperties *iface)
 127 {
 128     return 1;
 129 }
 130
 131 static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
 132     const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
 133 {
 134     ok(0, "unexpected call\n");
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
 139     const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets, DBPROPINFOSET **prgPropertyInfoSets,
 140     OLECHAR **ppDescBuffer)
 141 {
 142     ok(0, "unexpected call\n");
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG set_count, DBPROPSET propsets[])
 147 {
 148     ok(set_count == 1, "got %u\n", set_count);
 149
 150     ok(IsEqualIID(&propsets->guidPropertySet, &DBPROPSET_DBINIT), "set guid %s\n", wine_dbgstr_guid(&propsets->guidPropertySet));
 151     ok(propsets->cProperties == 2, "got propcount %u\n", propsets->cProperties);
 152
 153 if (propsets->cProperties == 2) {
 154     ok(propsets->rgProperties[0].dwPropertyID == DBPROP_INIT_DATASOURCE, "got propid[0] %u\n", propsets->rgProperties[0].dwPropertyID);
 155     ok(propsets->rgProperties[0].dwOptions == DBPROPOPTIONS_REQUIRED, "got options[0] %u\n", propsets->rgProperties[0].dwOptions);
 156     ok(propsets->rgProperties[0].dwStatus == 0, "got status[0] %u\n", propsets->rgProperties[0].dwStatus);
 157     ok(V_VT(&propsets->rgProperties[0].vValue) == VT_BSTR, "got vartype[0] %u\n", V_VT(&propsets->rgProperties[0].vValue));
 158
 159     ok(propsets->rgProperties[1].dwPropertyID == DBPROP_INIT_PROVIDERSTRING, "got propid[1] %u\n", propsets->rgProperties[1].dwPropertyID);
 160     ok(propsets->rgProperties[1].dwOptions == DBPROPOPTIONS_REQUIRED, "got options[1] %u\n", propsets->rgProperties[1].dwOptions);
 161     ok(propsets->rgProperties[1].dwStatus == 0, "got status[1] %u\n", propsets->rgProperties[1].dwStatus);
 162     ok(V_VT(&propsets->rgProperties[1].vValue) == VT_BSTR, "got vartype[1] %u\n", V_VT(&propsets->rgProperties[1].vValue));
 163 }
 164     return S_OK;
 165 }
 166
 167 static const IDBPropertiesVtbl dbpropsvtbl = {
 168     dbprops_QI,
 169     dbprops_AddRef,
 170     dbprops_Release,
 171     dbprops_GetProperties,
 172     dbprops_GetPropertyInfo,
 173     dbprops_SetProperties
 174 };
 175
 176 static IDBProperties dbprops = { &dbpropsvtbl };
 177
 178 /* IPersist stub */
 179 static HRESULT WINAPI dbpersist_QI(IPersist *iface, REFIID riid, void **obj)
 180 {
 181     if (IsEqualIID(riid, &IID_IPersist) || IsEqualIID(riid, &IID_IUnknown)) {
 182         *obj = iface;
 183         IPersist_AddRef(iface);
 184         return S_OK;
 185     }
 186
 187     *obj = NULL;
 188     return E_NOINTERFACE;
 189 }
 190
 191 static ULONG WINAPI dbpersist_AddRef(IPersist *iface)
 192 {
 193     return 2;
 194 }
 195
 196 static ULONG WINAPI dbpersist_Release(IPersist *iface)
 197 {
 198     return 1;
 199 }
 200
 201 static HRESULT WINAPI dbpersist_GetClassID(IPersist *iface, CLSID *clsid)
 202 {
 203     static const WCHAR msdasqlW[] = {'M','S','D','A','S','Q','L',0};
 204     return CLSIDFromProgID(msdasqlW, clsid);
 205 }
 206
 207 static const IPersistVtbl dbpersistvtbl = {
 208     dbpersist_QI,
 209     dbpersist_AddRef,
 210     dbpersist_Release,
 211     dbpersist_GetClassID
 212 };
 213
 214 static IPersist dbpersist = { &dbpersistvtbl };
 215
 216 /* IDBInitialize stub */
 217 static HRESULT WINAPI dbinit_QI(IDBInitialize *iface, REFIID riid, void **obj)
 218 {
 219     if (IsEqualIID(riid, &IID_IDBInitialize) || IsEqualIID(riid, &IID_IUnknown)) {
 220         *obj = iface;
 221         IDBInitialize_AddRef(iface);
 222         return S_OK;
 223     }
 224     else if (IsEqualIID(riid, &IID_IPersist)) {
 225         *obj = &dbpersist;
 226         return S_OK;
 227     }
 228     else if (IsEqualIID(riid, &IID_IDBProperties)) {
 229         *obj = &dbprops;
 230         return S_OK;
 231     }
 232
 233     *obj = NULL;
 234     return E_NOINTERFACE;
 235 }
 236
 237 static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
 238 {
 239     return 2;
 240 }
 241
 242 static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
 243 {
 244     return 1;
 245 }
 246
 247 static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
 248 {
 249     ok(0, "unexpected call\n");
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
 254 {
 255     ok(0, "unexpected call\n");
 256     return E_NOTIMPL;
 257 }
 258
 259 static const IDBInitializeVtbl dbinitvtbl = {
 260     dbinit_QI,
 261     dbinit_AddRef,
 262     dbinit_Release,
 263     dbinit_Initialize,
 264     dbinit_Uninitialize
 265 };
 266
 267 static IDBInitialize dbinittest = { &dbinitvtbl };
 268
 269 static void test_GetDataSource2(WCHAR *initstring)
 270 {
 271     IDataInitialize *datainit = NULL;
 272     IDBInitialize *dbinit = NULL;
 273     HRESULT hr;
 274
 275     hr = CoCreateInstance(&CLSID_MSDAINITIALIZE, NULL, CLSCTX_INPROC_SERVER, &IID_IDataInitialize,(void**)&datainit);
 276     ok(hr == S_OK, "got %08x\n", hr);
 277
 278     dbinit = &dbinittest;
 279     hr = IDataInitialize_GetDataSource(datainit, NULL, CLSCTX_INPROC_SERVER, initstring, &IID_IDBInitialize, (IUnknown**)&dbinit);
 280     ok(hr == S_OK, "got %08x\n", hr);
 281
 282     IDataInitialize_Release(datainit);
 283 }
 284
 285 static void test_database(void)
 286 {
 287     static WCHAR initstring_jet[] = {'P','r','o','v','i','d','e','r','=','M','i','c','r','o','s','o','f','t','.',
 288          'J','e','t','.','O','L','E','D','B','.','4','.','0',';',
 289          'D','a','t','a',' ','S','o','u','r','c','e','=','d','u','m','m','y',';',
 290          'P','e','r','s','i','s','t',' ','S','e','c','u','r','i','t','y',' ','I','n','f','o','=','F','a','l','s','e',';',0};
 291     static WCHAR initstring_lower[] = {'d','a','t','a',' ','s','o','u','r','c','e','=','d','u','m','m','y',';',0};
 292     static WCHAR customprop[] = {'d','a','t','a',' ','s','o','u','r','c','e','=','d','u','m','m','y',';',
 293         'c','u','s','t','o','m','p','r','o','p','=','1','2','3','.','4',';',0};
 294     IDataInitialize *datainit = NULL;
 295     HRESULT hr;
 296
 297     hr = CoCreateInstance(&CLSID_MSDAINITIALIZE, NULL, CLSCTX_INPROC_SERVER, &IID_IDataInitialize, (void**)&datainit);
 298     if (FAILED(hr))
 299     {
 300         win_skip("Unable to load oledb library\n");
 301         return;
 302     }
 303     IDataInitialize_Release(datainit);
 304
 305     test_GetDataSource(NULL);
 306     test_GetDataSource(initstring_jet);
 307     test_GetDataSource(initstring_default);
 308     test_GetDataSource(initstring_lower);
 309     test_GetDataSource2(customprop);
 310 }
 311
 312 static void test_errorinfo(void)
 313 {
 314     HRESULT hr;
 315     IUnknown *unk = NULL;
 316
 317     hr = CoCreateInstance(&CSLID_MSDAER, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown,(void**)&unk);
 318     ok(hr == S_OK, "got %08x\n", hr);
 319     if(hr == S_OK)
 320     {
 321         IErrorInfo *errorinfo;
 322         IErrorRecords *errrecs;
 323
 324         hr = IUnknown_QueryInterface(unk, &IID_IErrorInfo, (void**)&errorinfo);
 325         ok(hr == S_OK, "got %08x\n", hr);
 326         if(hr == S_OK)
 327         {
 328             IErrorInfo_Release(errorinfo);
 329         }
 330
 331         hr = IUnknown_QueryInterface(unk, &IID_IErrorRecords, (void**)&errrecs);
 332         ok(hr == S_OK, "got %08x\n", hr);
 333         if(hr == S_OK)
 334         {
 335             ERRORINFO info, info2, info3;
 336             ULONG cnt = 0;
 337
 338             memset(&info, 0, sizeof(ERRORINFO));
 339             info.dwMinor = 1;
 340             memset(&info2, 0, sizeof(ERRORINFO));
 341             info2.dwMinor = 2;
 342             memset(&info3, 0, sizeof(ERRORINFO));
 343
 344             hr = IErrorRecords_AddErrorRecord(errrecs, NULL, 268435456, NULL, NULL, 0);
 345             ok(hr == E_INVALIDARG, "got %08x\n", hr);
 346
 347             hr = IErrorRecords_AddErrorRecord(errrecs, &info, 1, NULL, NULL, 0);
 348             ok(hr == S_OK, "got %08x\n", hr);
 349
 350             hr = IErrorRecords_GetRecordCount(errrecs, &cnt);
 351             ok(hr == S_OK, "got %08x\n", hr);
 352             ok(cnt == 1, "expected 1 got %d\n", cnt);
 353
 354             hr = IErrorRecords_AddErrorRecord(errrecs, &info2, 2, NULL, NULL, 0);
 355             ok(hr == S_OK, "got %08x\n", hr);
 356
 357             hr = IErrorRecords_GetRecordCount(errrecs, &cnt);
 358             ok(hr == S_OK, "got %08x\n", hr);
 359             ok(cnt == 2, "expected 2 got %d\n", cnt);
 360
 361             hr = IErrorRecords_GetBasicErrorInfo(errrecs, 0, NULL);
 362             ok(hr == E_INVALIDARG, "got %08x\n", hr);
 363
 364             hr = IErrorRecords_GetBasicErrorInfo(errrecs, 100, &info3);
 365             ok(hr == DB_E_BADRECORDNUM, "got %08x\n", hr);
 366
 367             hr = IErrorRecords_GetBasicErrorInfo(errrecs, 0, &info3);
 368             todo_wine ok(hr == S_OK, "got %08x\n", hr);
 369             if(hr == S_OK)
 370             {
 371                 ok(info3.dwMinor == 2, "expected 2 got %d\n", info3.dwMinor);
 372             }
 373
 374             IErrorRecords_Release(errrecs);
 375         }
 376
 377         IUnknown_Release(unk);
 378     }
 379 }
 380
 381 static void test_initializationstring(void)
 382 {
 383     static const WCHAR initstring_msdasql[] = {'P','r','o','v','i','d','e','r','=','M','S','D','A','S','Q','L','.','1',';',
 384          'D','a','t','a',' ','S','o','u','r','c','e','=','d','u','m','m','y', 0};
 385     static const WCHAR initstring_sqloledb[] = {'P','r','o','v','i','d','e','r','=','S','Q','L','O','L','E','D','B','.','1',';',
 386          'D','a','t','a',' ','S','o','u','r','c','e','=','d','u','m','m','y', 0};
 387     IDataInitialize *datainit = NULL;
 388     IDBInitialize *dbinit;
 389     HRESULT hr;
 390     WCHAR *initstring = NULL;
 391
 392     hr = CoCreateInstance(&CLSID_MSDAINITIALIZE, NULL, CLSCTX_INPROC_SERVER, &IID_IDataInitialize,(void**)&datainit);
 393     ok(hr == S_OK, "got %08x\n", hr);
 394     if(SUCCEEDED(hr))
 395     {
 396         EXPECT_REF(datainit, 1);
 397
 398         dbinit = NULL;
 399         hr = IDataInitialize_GetDataSource(datainit, NULL, CLSCTX_INPROC_SERVER, initstring_default,
 400                                                                 &IID_IDBInitialize, (IUnknown**)&dbinit);
 401         if(SUCCEEDED(hr))
 402         {
 403             EXPECT_REF(datainit, 1);
 404             EXPECT_REF(dbinit, 1);
 405
 406             hr = IDataInitialize_GetInitializationString(datainit, (IUnknown*)dbinit, 0, &initstring);
 407             ok(hr == S_OK, "got %08x\n", hr);
 408             if(hr == S_OK)
 409             {
 410                 trace("Init String: %s\n", wine_dbgstr_w(initstring));
 411                 todo_wine ok(!lstrcmpW(initstring_msdasql, initstring) ||
 412                              !lstrcmpW(initstring_sqloledb, initstring), "got %s\n", wine_dbgstr_w(initstring));
 413                 CoTaskMemFree(initstring);
 414             }
 415
 416             IDBInitialize_Release(dbinit);
 417         }
 418         else
 419             ok(dbinit == NULL, "got %p\n", dbinit);
 420
 421         IDataInitialize_Release(datainit);
 422     }
 423 }
 424
 425 static void test_rowposition(void)
 426 {
 427     IEnumConnectionPoints *enum_points;
 428     IConnectionPointContainer *cpc;
 429     IConnectionPoint *cp;
 430     IRowPosition *rowpos;
 431     HRESULT hr;
 432     IID iid;
 433
 434     hr = CoCreateInstance(&CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IRowPosition, (void**)&rowpos);
 435     ok(hr == S_OK, "got %08x\n", hr);
 436
 437     hr = IRowPosition_QueryInterface(rowpos, &IID_IConnectionPointContainer, (void**)&cpc);
 438     ok(hr == S_OK, "got 0x%08x\n", hr);
 439
 440     hr = IConnectionPointContainer_EnumConnectionPoints(cpc, &enum_points);
 441 todo_wine
 442     ok(hr == S_OK, "got 0x%08x\n", hr);
 443 if (hr == S_OK) {
 444     hr = IEnumConnectionPoints_Next(enum_points, 1, &cp, NULL);
 445     ok(hr == S_OK, "got 0x%08x\n", hr);
 446     hr = IConnectionPoint_GetConnectionInterface(cp, &iid);
 447     ok(hr == S_OK, "got 0x%08x\n", hr);
 448     ok(IsEqualIID(&iid, &IID_IRowPositionChange), "got %s\n", wine_dbgstr_guid(&iid));
 449     IConnectionPoint_Release(cp);
 450
 451     hr = IEnumConnectionPoints_Next(enum_points, 1, &cp, NULL);
 452     ok(hr == S_FALSE, "got 0x%08x\n", hr);
 453
 454     IEnumConnectionPoints_Release(enum_points);
 455 }
 456     IConnectionPointContainer_Release(cpc);
 457     IRowPosition_Release(rowpos);
 458 }
 459
 460 typedef struct
 461 {
 462     IRowset IRowset_iface;
 463     IChapteredRowset IChapteredRowset_iface;
 464 } test_rset_t;
 465
 466 static test_rset_t test_rset;
 467
 468 static HRESULT WINAPI rset_QI(IRowset *iface, REFIID riid, void **obj)
 469 {
 470     if (IsEqualIID(riid, &IID_IUnknown) ||
 471         IsEqualIID(riid, &IID_IRowset))
 472     {
 473         *obj = &test_rset.IRowset_iface;
 474         return S_OK;
 475     }
 476     else if (IsEqualIID(riid, &IID_IChapteredRowset))
 477     {
 478         *obj = &test_rset.IChapteredRowset_iface;
 479         return S_OK;
 480     }
 481
 482     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
 483     return E_NOINTERFACE;
 484 }
 485
 486 static ULONG WINAPI rset_AddRef(IRowset *iface)
 487 {
 488     return 2;
 489 }
 490
 491 static ULONG WINAPI rset_Release(IRowset *iface)
 492 {
 493     return 1;
 494 }
 495
 496 static HRESULT WINAPI rset_AddRefRows(IRowset *iface, DBCOUNTITEM cRows,
 497     const HROW rghRows[], DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 498 {
 499     trace("AddRefRows: %ld\n", rghRows[0]);
 500     return S_OK;
 501 }
 502
 503 static HRESULT WINAPI rset_GetData(IRowset *iface, HROW hRow, HACCESSOR hAccessor, void *pData)
 504 {
 505     ok(0, "unexpected call\n");
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI rset_GetNextRows(IRowset *iface, HCHAPTER hReserved, DBROWOFFSET lRowsOffset,
 510     DBROWCOUNT cRows, DBCOUNTITEM *pcRowObtained, HROW **prghRows)
 511 {
 512     ok(0, "unexpected call\n");
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI rset_ReleaseRows(IRowset *iface, DBCOUNTITEM cRows, const HROW rghRows[], DBROWOPTIONS rgRowOptions[],
 517     DBREFCOUNT rgRefCounts[], DBROWSTATUS rgRowStatus[])
 518 {
 519     return S_OK;
 520 }
 521
 522 static HRESULT WINAPI rset_RestartPosition(IRowset *iface, HCHAPTER hReserved)
 523 {
 524     ok(0, "unexpected call\n");
 525     return E_NOTIMPL;
 526 }
 527
 528 static const IRowsetVtbl rset_vtbl = {
 529     rset_QI,
 530     rset_AddRef,
 531     rset_Release,
 532     rset_AddRefRows,
 533     rset_GetData,
 534     rset_GetNextRows,
 535     rset_ReleaseRows,
 536     rset_RestartPosition
 537 };
 538
 539 static HRESULT WINAPI chrset_QI(IChapteredRowset *iface, REFIID riid, void **obj)
 540 {
 541     return IRowset_QueryInterface(&test_rset.IRowset_iface, riid, obj);
 542 }
 543
 544 static ULONG WINAPI chrset_AddRef(IChapteredRowset *iface)
 545 {
 546     return IRowset_AddRef(&test_rset.IRowset_iface);
 547 }
 548
 549 static ULONG WINAPI chrset_Release(IChapteredRowset *iface)
 550 {
 551     return IRowset_Release(&test_rset.IRowset_iface);
 552 }
 553
 554 static HRESULT WINAPI chrset_AddRefChapter(IChapteredRowset *iface, HCHAPTER chapter, DBREFCOUNT *refcount)
 555 {
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI chrset_ReleaseChapter(IChapteredRowset *iface, HCHAPTER chapter, DBREFCOUNT *refcount)
 560 {
 561     return S_OK;
 562 }
 563
 564 static const IChapteredRowsetVtbl chrset_vtbl = {
 565     chrset_QI,
 566     chrset_AddRef,
 567     chrset_Release,
 568     chrset_AddRefChapter,
 569     chrset_ReleaseChapter
 570 };
 571
 572 static void init_test_rset(void)
 573 {
 574     test_rset.IRowset_iface.lpVtbl = &rset_vtbl;
 575     test_rset.IChapteredRowset_iface.lpVtbl = &chrset_vtbl;
 576 }
 577
 578 static void test_rowpos_initialize(void)
 579 {
 580     IRowPosition *rowpos;
 581     HRESULT hr;
 582
 583     hr = CoCreateInstance(&CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IRowPosition, (void**)&rowpos);
 584     ok(hr == S_OK, "got %08x\n", hr);
 585
 586     init_test_rset();
 587     hr = IRowPosition_Initialize(rowpos, (IUnknown*)&test_rset.IRowset_iface);
 588     ok(hr == S_OK, "got %08x\n", hr);
 589
 590     IRowPosition_Release(rowpos);
 591 }
 592
 593 static HRESULT WINAPI onchange_QI(IRowPositionChange *iface, REFIID riid, void **obj)
 594 {
 595     if (IsEqualIID(riid, &IID_IUnknown) ||
 596         IsEqualIID(riid, &IID_IRowPositionChange))
 597     {
 598         *obj = iface;
 599         return S_OK;
 600     }
 601
 602     return E_NOINTERFACE;
 603 }
 604
 605 static ULONG WINAPI onchange_AddRef(IRowPositionChange *iface)
 606 {
 607     return 2;
 608 }
 609
 610 static ULONG WINAPI onchange_Release(IRowPositionChange *iface)
 611 {
 612     return 1;
 613 }
 614
 615 static HRESULT WINAPI onchange_OnRowPositionChange(IRowPositionChange *iface, DBREASON reason,
 616     DBEVENTPHASE phase, BOOL cant_deny)
 617 {
 618     trace("%d %d %d\n", reason, phase, cant_deny);
 619     return S_OK;
 620 }
 621
 622 static const IRowPositionChangeVtbl onchange_vtbl = {
 623     onchange_QI,
 624     onchange_AddRef,
 625     onchange_Release,
 626     onchange_OnRowPositionChange
 627 };
 628
 629 static IRowPositionChange onchangesink = { &onchange_vtbl };
 630
 631 static void init_onchange_sink(IRowPosition *rowpos)
 632 {
 633     IConnectionPointContainer *cpc;
 634     IConnectionPoint *cp;
 635     DWORD cookie;
 636     HRESULT hr;
 637
 638     hr = IRowPosition_QueryInterface(rowpos, &IID_IConnectionPointContainer, (void**)&cpc);
 639     ok(hr == S_OK, "got %08x\n", hr);
 640     hr = IConnectionPointContainer_FindConnectionPoint(cpc, &IID_IRowPositionChange, &cp);
 641     ok(hr == S_OK, "got %08x\n", hr);
 642     hr = IConnectionPoint_Advise(cp, (IUnknown*)&onchangesink, &cookie);
 643     ok(hr == S_OK, "got %08x\n", hr);
 644     IConnectionPoint_Release(cp);
 645     IConnectionPointContainer_Release(cpc);
 646 }
 647
 648 static void test_rowpos_clearrowposition(void)
 649 {
 650     DBPOSITIONFLAGS flags;
 651     IRowPosition *rowpos;
 652     HCHAPTER chapter;
 653     IUnknown *unk;
 654     HRESULT hr;
 655     HROW row;
 656
 657     hr = CoCreateInstance(&CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IRowPosition, (void**)&rowpos);
 658     ok(hr == S_OK, "got %08x\n", hr);
 659
 660     hr = IRowPosition_ClearRowPosition(rowpos);
 661     ok(hr == E_UNEXPECTED, "got %08x\n", hr);
 662
 663     hr = IRowPosition_GetRowset(rowpos, &IID_IStream, &unk);
 664     ok(hr == E_UNEXPECTED, "got %08x\n", hr);
 665
 666     chapter = 1;
 667     row = 1;
 668     flags = DBPOSITION_OK;
 669     hr = IRowPosition_GetRowPosition(rowpos, &chapter, &row, &flags);
 670     ok(hr == E_UNEXPECTED, "got %08x\n", hr);
 671     ok(chapter == DB_NULL_HCHAPTER, "got %ld\n", chapter);
 672     ok(row == DB_NULL_HROW, "got %ld\n", row);
 673     ok(flags == DBPOSITION_NOROW, "got %d\n", flags);
 674
 675     init_test_rset();
 676     hr = IRowPosition_Initialize(rowpos, (IUnknown*)&test_rset.IRowset_iface);
 677     ok(hr == S_OK, "got %08x\n", hr);
 678
 679     chapter = 1;
 680     row = 1;
 681     flags = DBPOSITION_OK;
 682     hr = IRowPosition_GetRowPosition(rowpos, &chapter, &row, &flags);
 683     ok(hr == S_OK, "got %08x\n", hr);
 684     ok(chapter == DB_NULL_HCHAPTER, "got %ld\n", chapter);
 685     ok(row == DB_NULL_HROW, "got %ld\n", row);
 686     ok(flags == DBPOSITION_NOROW, "got %d\n", flags);
 687
 688     hr = IRowPosition_GetRowset(rowpos, &IID_IRowset, &unk);
 689     ok(hr == S_OK, "got %08x\n", hr);
 690
 691     init_onchange_sink(rowpos);
 692     hr = IRowPosition_ClearRowPosition(rowpos);
 693     ok(hr == S_OK, "got %08x\n", hr);
 694
 695     chapter = 1;
 696     row = 1;
 697     flags = DBPOSITION_OK;
 698     hr = IRowPosition_GetRowPosition(rowpos, &chapter, &row, &flags);
 699     ok(hr == S_OK, "got %08x\n", hr);
 700     ok(chapter == DB_NULL_HCHAPTER, "got %ld\n", chapter);
 701     ok(row == DB_NULL_HROW, "got %ld\n", row);
 702     ok(flags == DBPOSITION_NOROW, "got %d\n", flags);
 703
 704     IRowPosition_Release(rowpos);
 705 }
 706
 707 static void test_rowpos_setrowposition(void)
 708 {
 709     IRowPosition *rowpos;
 710     HRESULT hr;
 711
 712     hr = CoCreateInstance(&CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IRowPosition, (void**)&rowpos);
 713     ok(hr == S_OK, "got %08x\n", hr);
 714
 715     init_test_rset();
 716     hr = IRowPosition_Initialize(rowpos, (IUnknown*)&test_rset.IRowset_iface);
 717     ok(hr == S_OK, "got %08x\n", hr);
 718
 719     hr = IRowPosition_ClearRowPosition(rowpos);
 720     ok(hr == S_OK, "got %08x\n", hr);
 721
 722     init_onchange_sink(rowpos);
 723     hr = IRowPosition_SetRowPosition(rowpos, 0x123, 0x456, DBPOSITION_OK);
 724     ok(hr == S_OK, "got %08x\n", hr);
 725
 726     IRowPosition_Release(rowpos);
 727 }
 728
 729 static void test_dslocator(void)
 730 {
 731     IDataSourceLocator *dslocator = NULL;
 732     HRESULT hr;
 733
 734     hr = CoCreateInstance(&CLSID_DataLinks, NULL, CLSCTX_INPROC_SERVER, &IID_IDataSourceLocator,(void**)&dslocator);
 735     ok(hr == S_OK, "got %08x\n", hr);
 736     if(SUCCEEDED(hr))
 737     {
 738         COMPATIBLE_LONG hwnd = 0;
 739
 740         if (0) /* Crashes under Window 7 */
 741             hr = IDataSourceLocator_get_hWnd(dslocator, NULL);
 742
 743         hr = IDataSourceLocator_get_hWnd(dslocator, &hwnd);
 744         ok(hr == S_OK, "got %08x\n", hr);
 745         ok(hwnd == 0, "got %p\n", (HWND)hwnd);
 746
 747         hwnd = 0xDEADBEEF;
 748         hr = IDataSourceLocator_get_hWnd(dslocator, &hwnd);
 749         ok(hr == S_OK, "got %08x\n", hr);
 750         ok(hwnd == 0, "got %p\n", (HWND)hwnd);
 751
 752         hwnd = 0xDEADBEEF;
 753         hr = IDataSourceLocator_put_hWnd(dslocator, hwnd);
 754         ok(hr == S_OK, "got %08x\n", hr);
 755
 756         hwnd = 0;
 757         hr = IDataSourceLocator_get_hWnd(dslocator, &hwnd);
 758         ok(hr == S_OK, "got %08x\n", hr);
 759         ok(hwnd == 0xDEADBEEF, "got %p\n", (HWND)hwnd);
 760
 761         hwnd = 0;
 762         hr = IDataSourceLocator_put_hWnd(dslocator, hwnd);
 763         ok(hr == S_OK, "got %08x\n", hr);
 764
 765         hwnd = 0xDEADBEEF;
 766         hr = IDataSourceLocator_get_hWnd(dslocator, &hwnd);
 767         ok(hr == S_OK, "got %08x\n", hr);
 768         ok(hwnd == 0, "got %p\n", (HWND)hwnd);
 769
 770         IDataSourceLocator_Release(dslocator);
 771     }
 772 }
 773
 774 START_TEST(database)
 775 {
 776     OleInitialize(NULL);
 777
 778     test_database();
 779     test_errorinfo();
 780     test_initializationstring();
 781     test_dslocator();
 782
 783     /* row position */
 784     test_rowposition();
 785     test_rowpos_initialize();
 786     test_rowpos_clearrowposition();
 787     test_rowpos_setrowposition();
 788
 789     OleUninitialize();
 790 }