//-------------------------------------------------------------------- // Microsoft OLE DB Test // // Copyright (C) 1995-2000 Microsoft Corporation // // @doc // // @module IGETSOURCEROW.CPP | IGETSOURCEROW source file for all test modules. // #include "modstandard.hpp" #include "IGETSOURCEROW.h" #include "ExtraLib.h" // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Module Values // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // {{ TCW_MODULE_GLOBALS DECLARE_MODULE_CLSID = { 0xd88d6ef0, 0x5be5, 0x11d2, { 0x92, 0xd2, 0x00, 0x60, 0x08, 0x93, 0xa2, 0xb2} }; DECLARE_MODULE_NAME("IGetSourceRow"); DECLARE_MODULE_OWNER("Microsoft"); DECLARE_MODULE_DESCRIP("IGetSourceRow test"); DECLARE_MODULE_VERSION(795921705); // TCW_WizardVersion(2) // TCW_Automation(True) // }} TCW_MODULE_GLOBALS_END //-------------------------------------------------------------------- // @func Module level initialization routine // // @rdesc Success or Failure // @flag TRUE | Successful initialization // @flag FALSE | Initialization problems // BOOL ModuleInit(CThisTestModule * pThisTestModule) { // return CommonModuleInit(pThisTestModule /*, IID_IGetSourceRow */); // Check for Row object support in the provider return CommonModuleInit(pThisTestModule, IID_IRow, SIZEOF_TABLE, ROW_INTERFACE); } //-------------------------------------------------------------------- // @func Module level termination routine // // @rdesc Success or Failure // @flag TRUE | Successful initialization // @flag FALSE | Initialization problems // BOOL ModuleTerminate(CThisTestModule * pThisTestModule) { return CommonModuleTerminate(pThisTestModule); } //////////////////////////////////////////////////////////////////////// //CStreamObject // //////////////////////////////////////////////////////////////////////// class CStreamObject { public: // Constructors CStreamObject(); virtual ~CStreamObject(void); // Members HRESULT InitStreamObject ( IBindResource * pIBindResource, WCHAR * pwszURL ); HRESULT InitStreamObject ( IRow * pIRow ); HRESULT InitStreamObject ( IScopedOperations * pIScopedOperations, REFIID riid = IID_IStream ); HRESULT InitStreamObject ( ICreateRow * pICreateRow, WCHAR * pwszURL, REFIID riid = IID_IStream, WCHAR ** ppwszNewURL = NULL ); HRESULT InitStreamObject ( IRow * pIRow, WCHAR * pwszColName ); HRESULT InitStreamUsingGetColumns ( IRow * pIRow ); HRESULT SetStreamObject ( IUnknown * pUnkStream ); HRESULT GetSourceRow ( REFIID riid, IUnknown ** ppIRow ); void ReleaseStreamObject(); IStream * pIStream() { ASSERT(m_pIStream); return m_pIStream; } IGetSourceRow * pIGetSourceRow() { ASSERT(m_pIGetSourceRow); return m_pIGetSourceRow; } inline DBBINDURLFLAG GetBindURLFlags() { return m_dwBindFlags; } inline void SetBindURLFlags(DBBINDURLFLAG dwBindFlags) { m_dwBindFlags = dwBindFlags; } protected: // Data IStream * m_pIStream; IGetSourceRow * m_pIGetSourceRow; DBBINDURLFLAG m_dwBindFlags; DBBINDURLSTATUS m_dwBindStatus; }; ///////////////////////////////////////////////////////////////////////////// // CStreamObject // ///////////////////////////////////////////////////////////////////////////// CStreamObject::CStreamObject() { //Interfaces m_pIStream = NULL; m_pIGetSourceRow = NULL; //data m_dwBindFlags = DBBINDURLFLAG_READ; m_dwBindStatus = 0; } ///////////////////////////////////////////////////////////////////////////// // ~CStreamObject // ///////////////////////////////////////////////////////////////////////////// CStreamObject::~CStreamObject() { ReleaseStreamObject(); } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamObject ( IBindResource * pIBindResource, WCHAR * pwszURL ) { HRESULT hr; DBBINDURLSTATUS dwStatus = 0; if(!pIBindResource) { odtLog<Bind ( NULL, pwszURL, m_dwBindFlags, DBGUID_STREAM, IID_IStream, NULL, NULL, &m_dwBindStatus, (IUnknown **)&m_pIStream ),S_OK); TESTC_(hr = m_pIStream->QueryInterface(IID_IGetSourceRow, (void **)&m_pIGetSourceRow), S_OK); CLEANUP: if( FAILED(hr) ) { ReleaseStreamObject(); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamObject ( IRow * pIRow ) { HRESULT hr; DBID dbidCol = DBROWCOL_DEFAULTSTREAM; if(!pIRow) { odtLog<Open(NULL, &dbidCol, DBGUID_STREAM, 0, IID_IStream, (IUnknown**)&m_pIStream), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC_(hr = m_pIStream->QueryInterface(IID_IGetSourceRow, (void **)&m_pIGetSourceRow), S_OK); } CLEANUP: if( FAILED(hr) ) { ReleaseStreamObject(); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamObject ( ICreateRow * pICreateRow, WCHAR * pwszURL, REFIID riid, WCHAR ** ppwszNewURL ) { HRESULT hr; DBBINDURLSTATUS dwStatus = 0; IUnknown * pUnk = NULL; WCHAR * pwszNewURL = NULL; if(!pICreateRow) { odtLog<CreateRow ( NULL, pwszURL, m_dwBindFlags, DBGUID_STREAM, riid, NULL, NULL, &m_dwBindStatus, &pwszNewURL, (IUnknown **)&pUnk ), S_OK, E_NOINTERFACE); if( hr == S_OK ) { TESTC_(hr = pUnk->QueryInterface(IID_IStream, (void **)&m_pIStream), S_OK); TESTC_(hr = pUnk->QueryInterface(IID_IGetSourceRow, (void **)&m_pIGetSourceRow), S_OK); } CLEANUP: SAFE_RELEASE(pUnk); if( FAILED(hr) ) { ReleaseStreamObject(); SAFE_FREE(pwszNewURL); } else { if (ppwszNewURL) *ppwszNewURL = pwszNewURL; else SAFE_FREE(pwszNewURL); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamObject ( IScopedOperations * pIScopedOperations, REFIID riid ) { HRESULT hr; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); IUnknown * pUnk = NULL; DBBINDURLSTATUS dwStatus = 0; if(!pIScopedOperations) { odtLog<Bind ( NULL, pwszURL, m_dwBindFlags, DBGUID_STREAM, riid, NULL, NULL, &m_dwBindStatus, (IUnknown **)&pUnk ),S_OK); TESTC_(hr = pUnk->QueryInterface(IID_IStream, (void **)&m_pIStream), S_OK); TESTC_(hr = pUnk->QueryInterface(IID_IGetSourceRow, (void **)&m_pIGetSourceRow), S_OK); CLEANUP: SAFE_RELEASE(pUnk); if( FAILED(hr) ) { ReleaseStreamObject(); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamObject ( IRow * pIRow, WCHAR * pwszStreamColName ) { HRESULT hr = E_FAIL; DBCOLUMNACCESS dbColAccess; IUnknown * pIUnknown = NULL;; if(!pIRow) { odtLog<GetColumns(1, &dbColAccess), S_OK, DB_E_ERRORSOCCURRED); if( SUCCEEDED(hr) ) { pIUnknown = *(IUnknown **)(dbColAccess.pData); TESTC(pIUnknown != NULL); // IGetSourceRow may not be available from storage object retrieved by IRow::GetColumns QTESTC_(hr = pIUnknown->QueryInterface(IID_IGetSourceRow, (void **)&m_pIGetSourceRow), S_OK); QTESTC_(hr = pIUnknown->QueryInterface(IID_IStream, (void **)&m_pIStream), S_OK); } else { if( hr == DB_E_ERRORSOCCURRED ) { // Raise error on failure to get DEFAULTSTREAM TESTC( dbColAccess.dwStatus == DBSTATUS_E_DOESNOTEXIST ); hr = DB_E_BADCOLUMNID; } } CLEANUP: SAFE_RELEASE(pIUnknown); SAFE_FREE(dbColAccess.pData); if( FAILED(hr) ) { ReleaseStreamObject(); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::InitStreamUsingGetColumns // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::InitStreamUsingGetColumns ( IRow * pIRow ) { HRESULT hr = E_FAIL; CRowObject RowObjectA; DBCOUNTITEM cColAccess; ULONG_PTR cbRowSize; DBCOLUMNACCESS * rgColAccess = NULL; void * pData = NULL; IUnknown * pUnk = NULL; // Try to bind to the first column that may get us a Stream object TESTC_(hr = RowObjectA.SetRowObject(pIRow),S_OK); TESTC_(hr = RowObjectA.CreateColAccess(&cColAccess, &rgColAccess, &pData, &cbRowSize, BLOB_COLS_BOUND, BLOB_IID_IUNKNOWN), S_OK); if( cColAccess ) { TESTC_(hr = RowObjectA.GetColumns(1, rgColAccess), S_OK); pUnk = *(IUnknown **)rgColAccess[0].pData; hr = SetStreamObject(pUnk); } else hr = E_NOINTERFACE; CLEANUP: SAFE_RELEASE(pUnk); SAFE_FREE(pData); SAFE_FREE(rgColAccess); if( FAILED(hr) ) { ReleaseStreamObject(); } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::SetStreamObject // ///////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::SetStreamObject ( IUnknown * pUnkStream ) { HRESULT hr = S_OK; IStream * pIStream = NULL; // ISequentialStream is a mandatory interface on the stream object, but IStream // is optional... if(!VerifyInterface(pUnkStream, IID_ISequentialStream, STREAM_INTERFACE, (IUnknown**)&pIStream)) return E_NOINTERFACE; //Release the previous stream object ReleaseStreamObject(); //Now that everything worked successfully, save the interface... m_pIStream = pIStream; // IGetSourceRow is optional on the stream object if(!VerifyInterface(m_pIStream, IID_IGetSourceRow, STREAM_INTERFACE, (IUnknown**)&m_pIGetSourceRow)) { SAFE_RELEASE(m_pIStream); return E_NOINTERFACE; } return hr; } ///////////////////////////////////////////////////////////////////////////// // CStreamObject::ReleaseStreamObject // ///////////////////////////////////////////////////////////////////////////// void CStreamObject::ReleaseStreamObject() { //Interfaces SAFE_RELEASE(m_pIStream); SAFE_RELEASE(m_pIGetSourceRow); } //////////////////////////////////////////////////////////////////////////// // CStreamObject::GetSourceRow // //////////////////////////////////////////////////////////////////////////// HRESULT CStreamObject::GetSourceRow ( REFIID riid, IUnknown ** ppIRow ) { //IGetSource::GetSourceRowset HRESULT hr; if(!m_pIGetSourceRow) return E_NOINTERFACE; hr = m_pIGetSourceRow->GetSourceRow(riid, ppIRow); //Do some postprocessing if(SUCCEEDED(hr) && ppIRow) { TESTC(*ppIRow != NULL); } else { if(ppIRow) { TESTC(*ppIRow == NULL); } } CLEANUP: return hr; } //////////////////////////////////////////////////////////////////////////// // TCBase // //////////////////////////////////////////////////////////////////////////// class TCBase { public: //constructor TCBase() { SetTestCaseParam(TC_Empty); } //methods virtual void SetTestCaseParam(ETESTCASE eTestCase = TC_Empty) { m_eTestCase = eTestCase; } //data ETESTCASE m_eTestCase; }; //////////////////////////////////////////////////////////////////////// //TCIGetSourceRow Class // //////////////////////////////////////////////////////////////////////// class TCIGetSourceRow : public CRowset, public TCBase { public: //Constructor TCIGetSourceRow(WCHAR* pwszTestCaseName); //Destructor virtual ~TCIGetSourceRow(); //methods virtual BOOL Init(ETESTCASE eTestCase = TC_Empty); virtual BOOL Terminate(); virtual HRESULT TestGetSourceRow ( CStreamObject * pCStreamObj ); virtual HRESULT TestMultipleStreams ( ULONG_PTR cStreamObjects, ESTREAMSOURCE eStreamSource ); static ULONG WINAPI Thread_VerifyGetSourceRow ( LPVOID pv ); virtual BOOL VerifyGetSourceRow ( REFIID riid, IUnknown ** ppIRow = NULL ); static ULONG WINAPI Thread_GetColumns_VerifyGetSourceRow ( LPVOID pv ); virtual BOOL GetColumns_VerifyGetSourceRow ( CStreamObject * pStream, REFIID riid, IUnknown ** ppIRow = NULL ); static ULONG WINAPI Thread_ReleaseRow ( LPVOID pv ); virtual HRESULT BindRow ( IUnknown * pUnkOuter, IUnknown ** pUnknown ); virtual BOOL VerifyBLOBSFromRowObject ( CRowObject * pRowObj ); protected: IDBBinderProperties * m_pIDBBinderProperties; IBindResource * m_pIBindResource; ICreateRow * m_pICreateRow; HROW m_hRow; CRowObject * m_pCRowObject; CStreamObject * m_pCStreamObject; IRowset * m_pIRowset; private: HRESULT CreateRootBinder(); BOOL SetInitProps ( IDBBinderProperties * pIDBBindProp ); }; //////////////////////////////////////////////////////////////////////////// // TCIGetSourceRow::TCIGetSourceRow // //////////////////////////////////////////////////////////////////////////// TCIGetSourceRow::TCIGetSourceRow(WCHAR * wstrTestCaseName) : CRowset(wstrTestCaseName) { m_pCRowObject = NULL; m_pCStreamObject = NULL; m_pIRowset = NULL; m_pIDBBinderProperties = NULL; m_pIBindResource = NULL; m_pICreateRow = NULL; m_hRow = DB_NULL_HROW; } //////////////////////////////////////////////////////////////////////////// // TCIGetSourceRow::~TCIGetSourceRow // //////////////////////////////////////////////////////////////////////////// TCIGetSourceRow::~TCIGetSourceRow() { if( m_pCRowObject ) delete m_pCRowObject; if( m_pCStreamObject ) delete m_pCStreamObject; ASSERT(m_pIBindResource == NULL); ASSERT(m_pICreateRow == NULL); ASSERT(m_pIDBBinderProperties == NULL); ASSERT(m_pIRowset == NULL); } //////////////////////////////////////////////////////////////////////////// // TCIGetSourceRow::Init // //////////////////////////////////////////////////////////////////////////// BOOL TCIGetSourceRow::Init(ETESTCASE eTestCase) { BOOL fPass = TEST_FAIL; DBCOUNTITEM cRowsObtained = 0; HROW * rghRows = &m_hRow; IRow * pIRow = NULL; if(!CRowset::Init()) return FALSE; // Create Root Binder TESTC(SUCCEEDED(CreateRootBinder())) //Create a new row and stream object m_pCRowObject = new CRowObject; m_pCStreamObject = new CStreamObject; TESTC(m_pCRowObject != NULL && m_pCStreamObject != NULL); //May require IRowsetLocate to position on Blobs SetSettableProperty(DBPROP_IRowsetLocate); //May require ACCESSORDER RANDOM to allow multiple accesses to streams. //Otherwise reading a stream over a BLOB column may may prevent reading it again //because we've read past that BLOB column. Needed for multiple stream scenarios. SetSettableProperty(DBPROP_ACCESSORDER, DBPROPSET_ROWSET, (void *)DBPROPVAL_AO_RANDOM, VT_I4); //Create the Rowset object TESTC_(CreateRowset(), S_OK); TESTC_(GetRowObject(1, m_pCRowObject),S_OK); fPass = TEST_PASS; CLEANUP: ReleaseRows(m_hRow); SAFE_RELEASE(pIRow); return fPass; } //////////////////////////////////////////////////////////////////////////// // TCIGetSourceRow::Terminate // //////////////////////////////////////////////////////////////////////////// BOOL TCIGetSourceRow::Terminate() { SAFE_DELETE(m_pCRowObject); SAFE_DELETE(m_pCStreamObject); // Release the root binder interfaces m_pIBindResource = NULL; SAFE_RELEASE(m_pICreateRow); SAFE_RELEASE(m_pIDBBinderProperties); return CRowset::Terminate(); } //---------------------------------------------------------------------- // TCIGetSourceRow::CreateRootBinder // // lifted from IBindResource.cpp // probably should be in privlib HRESULT TCIGetSourceRow::CreateRootBinder() { HRESULT hrRet = E_FAIL; m_pIBindResource = GetModInfo()->GetRootBinder(); if(!m_pIBindResource) { odtLog<SetProperties(cPropSets, rgPropSets), S_OK)) bRet = TRUE; } ::FreeProperties(&cPropSets, &rgPropSets); return bRet; } //SetInitProps //---------------------------------------------------------------------- // TCIGetSourceRow::TestGetSourceRow // HRESULT TCIGetSourceRow::TestGetSourceRow ( CStreamObject * pCStreamObject ) { HRESULT hr; IUnknown * pIUnknown = NULL; ULONG cRowIIDs = 0; ULONG i; INTERFACEMAP * rgRowIIDs = NULL; //Obtain the Rowset interfaces... GetInterfaceArray(ROW_INTERFACE, &cRowIIDs, &rgRowIIDs); //For every [MANDATORY] interface, try to get the parent ROW object... for(i=0; iGetSourceRow(*rgRowIIDs[i].pIID, (IUnknown**)&pIUnknown); if (hr == DB_E_NOSOURCEOBJECT) { TWARNING(L"This stream did not have a source row object."); } //Determine results if(rgRowIIDs[i].fMandatory) { //[MANDATORY] if(hr!=S_OK && hr!=DB_E_NOSOURCEOBJECT) { CHECK(hr, S_OK); TOUTPUT_(L"ERROR: Interface Incorrect for " << GetInterfaceName(*rgRowIIDs[i].pIID) << "\n"); } } else { //[OPTIONAL] if(hr!=S_OK && hr!=DB_E_NOSOURCEOBJECT && hr!=E_NOINTERFACE) { CHECK(hr, S_OK); TOUTPUT_(L"ERROR: Interface Incorrect for " << GetInterfaceName(*rgRowIIDs[i].pIID) << "\n"); } } SAFE_RELEASE(pIUnknown); } //Verify E_NOINTERFACE for IID_NULL CHECK(pCStreamObject->GetSourceRow(IID_NULL, &pIUnknown), E_NOINTERFACE); SAFE_RELEASE(pIUnknown); //Verify E_INVALIDARG condition CHECK(pCStreamObject->GetSourceRow(IID_NULL, NULL), E_INVALIDARG); return S_OK; } //---------------------------------------------------------------------- // TCIGetSourceRow::TestMultipleStreams // HRESULT TCIGetSourceRow::TestMultipleStreams ( ULONG_PTR cStreamObjects, ESTREAMSOURCE eStreamSource ) { HRESULT hr; CStreamObject ** rgpCStreamObjects = NULL; IUnknown * pIUnknown = NULL; ULONG iStream; //Create the Stream Objects from the row handle obtained in ::Init SAFE_ALLOC(rgpCStreamObjects, CStreamObject*, cStreamObjects); memset(rgpCStreamObjects, 0, cStreamObjects * sizeof(CStreamObject*)); // Get cStreamObjects for(iStream=0; iStreamInitStreamObject(m_pCRowObject->pIRow()), S_OK, DB_E_BADCOLUMNID) } else if (EROWGETCOL == eStreamSource || (EROWBOTH == eStreamSource && (1 == iStream % 2))) { TEST3C_(hr = pCStreamObject->InitStreamUsingGetColumns(m_pCRowObject->pIRow()), S_OK, E_NOINTERFACE, DB_E_BADCOLUMNID); } else ASSERT(!"No Support yet"); if( S_OK == hr ) { //Try to get back to the creating rowset TEST2C_(pCStreamObject->GetSourceRow(IID_IUnknown, &pIUnknown), S_OK, DB_E_NOSOURCEOBJECT); if(pIUnknown) { //Make sure its returning the original object TESTC(VerifyEqualInterface(pIUnknown, m_pCRowObject->pIRow())); } SAFE_RELEASE(pIUnknown); } } CLEANUP: for(iStream=0; iStreamVerifyGetSourceRow(IID_IRow)); ThreadSwitch(); //Let the other thread(s) catch up CLEANUP: THREAD_RETURN } //---------------------------------------------------------------------- // TCIGetSourceRow::VerifyGetSourceRow // BOOL TCIGetSourceRow::VerifyGetSourceRow ( REFIID riid, IUnknown ** ppIRow ) { HRESULT hr = S_OK; BOOL fPass = TEST_FAIL; HROW hRow = DB_NULL_HROW; IUnknown * pIUnknown = NULL; //IGetSourceRow::GetSourceRow TESTC_(hr = m_pCStreamObject->GetSourceRow(riid, &pIUnknown),S_OK); //Verify the rowset returned TESTC(DefaultObjectTesting(pIUnknown, ROW_INTERFACE)); fPass = TEST_PASS; CLEANUP: if(ppIRow) *ppIRow = pIUnknown; else SAFE_RELEASE(pIUnknown); return fPass; } //---------------------------------------------------------------------- // TCIGetSourceRow::Thread_GetColumns_VerifyGetSourceRow // ULONG TCIGetSourceRow::Thread_GetColumns_VerifyGetSourceRow ( LPVOID pv ) { THREAD_BEGIN //Thread Stack Variables TCIGetSourceRow* pThis = (TCIGetSourceRow*)THREAD_FUNC; CStreamObject * pStream = (CStreamObject *)THREAD_ARG1; ASSERT(pThis); ThreadSwitch(); //Let the other thread(s) catch up TESTC(pThis->GetColumns_VerifyGetSourceRow(pStream, IID_IRow)); ThreadSwitch(); //Let the other thread(s) catch up CLEANUP: THREAD_RETURN } //---------------------------------------------------------------------- // TCIGetSourceRow::GetColumns_VerifyGetSourceRow // BOOL TCIGetSourceRow::GetColumns_VerifyGetSourceRow ( CStreamObject * pStream, REFIID riid, IUnknown ** ppIRow ) { HRESULT hr = S_OK; BOOL fPass = TEST_FAIL; IUnknown * pIUnknown = NULL; if( S_OK == hr ) { TESTC_(hr = pStream->GetSourceRow(riid, &pIUnknown), S_OK); //Verify the rowset returned TESTC(DefaultObjectTesting(pIUnknown, ROW_INTERFACE)); } fPass = TEST_PASS; CLEANUP: if(ppIRow) *ppIRow = pIUnknown; else SAFE_RELEASE(pIUnknown); return fPass; } //---------------------------------------------------------------------- // TCIGetSourceRow::Thread_ReleaseRow // ULONG TCIGetSourceRow::Thread_ReleaseRow ( LPVOID pv ) { THREAD_BEGIN //Thread Stack Variables CRowset * pRowset = (CRowset *)THREAD_FUNC; HROW * phrow = (HROW *)THREAD_ARG1; ASSERT(pRowset); ASSERT(phrow); ThreadSwitch(); //Let the other thread(s) catch up TESTC_(pRowset->ReleaseRows(*phrow), S_OK); ThreadSwitch(); //Let the other thread(s) catch up CLEANUP: THREAD_RETURN } //---------------------------------------------------------------------- // TCIGetSourceRow::BindRow // HRESULT TCIGetSourceRow::BindRow ( IUnknown * pUnkOuter, IUnknown ** ppUnknown ) { HRESULT hr; WCHAR * pwszRowURL = GetModInfo()->GetParseObject()->GetURL(ROW_INTERFACE); DBBINDURLSTATUS dwBindStatus = ~0; if(!pwszRowURL) { return S_FALSE; } TEST2C_(hr = m_pIBindResource->Bind ( pUnkOuter, pwszRowURL, DBBINDURLFLAG_READ, DBGUID_ROW, IID_IUnknown, NULL, NULL, &dwBindStatus, ppUnknown ), S_OK, DB_E_NOAGGREGATION); if( S_OK == hr ) TESTC(dwBindStatus == 0); CLEANUP: if( FAILED(hr) && ppUnknown ) { *ppUnknown = NULL; } return hr; } //---------------------------------------------------------------------- // TCIGetSourceRow::VerifyBLOBSFromRowObject // BOOL TCIGetSourceRow::VerifyBLOBSFromRowObject ( CRowObject * pRowObj ) { BOOL fPass = TEST_FAIL; HRESULT hr; IRow * pIRow = NULL; DBCOUNTITEM cColAccess = 0; DBCOLUMNACCESS * rgColAccess = NULL; void * pData = NULL; ULONG_PTR cbRowSize = 0; ULONG_PTR cIter = 0; TESTC_(pRowObj->CreateColAccess(&cColAccess, &rgColAccess, &pData, &cbRowSize, BLOB_COLS_BOUND, BLOB_IID_IUNKNOWN), S_OK); TESTC_(pRowObj->GetColumns(cColAccess, rgColAccess), S_OK); for( cIter = 0; cIter < cColAccess; cIter++ ) { CStreamObject StreamObjectA; IUnknown * pUnkStream = NULL; ILockBytes * pILockBytes = NULL; TESTC(rgColAccess[cIter].dwStatus == DBSTATUS_S_OK); pUnkStream = *(IUnknown **)rgColAccess[cIter].pData; if( S_OK == (hr = StreamObjectA.SetStreamObject(pUnkStream)) ) { CHECK(TestGetSourceRow(&StreamObjectA), S_OK); COMPARE(DefaultObjectTesting(StreamObjectA.pIGetSourceRow(), STREAM_INTERFACE), TRUE); } else { TWARNING(L"This storage object does not support IGetSourceRow."); } // Optionally see if the object supports ILockBytes // If so, just perform a simple read if(VerifyInterface(pUnkStream, IID_ILockBytes, STREAM_INTERFACE,(IUnknown**)&pILockBytes)) { BYTE bBuffer[MAX_COL_SIZE]; ULONG cBytes = 0; HRESULT hr; hr = StorageRead(IID_ILockBytes, pILockBytes, bBuffer, MAX_COL_SIZE, &cBytes); COMPARE(hr == S_OK || hr == S_FALSE, TRUE); COMPARE(DefaultObjectTesting(pILockBytes, STREAM_INTERFACE), TRUE); SAFE_RELEASE(pILockBytes); } SAFE_RELEASE(pUnkStream); } fPass = TEST_PASS; CLEANUP: SAFE_FREE(rgColAccess); SAFE_FREE(pData); SAFE_RELEASE(pIRow); return fPass; } // {{ TCW_TEST_CASE_MAP(TCIGetSourceRow_IUnknown) //-------------------------------------------------------------------- // @class Test IUnknown // class TCIGetSourceRow_IUnknown : public TCIGetSourceRow { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(TCIGetSourceRow_IUnknown,TCIGetSourceRow); // }} TCW_DECLARE_FUNCS_END // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember DefaultTesting IBindResource int Variation_1(); // @cmember DefaultTesting IRow_Open from GetRow int Variation_2(); // @cmember DefaultTesting IScopedOperations int Variation_3(); // @cmember DefaultTesting ICreateRow int Variation_4(); // @cmember DefaultTesting Session IBindResource int Variation_5(); // @cmember DefaultTesting Session ICreateRow int Variation_8(); // @cmember DefaultTesting IRow_GetColumns int Variation_9(); // @cmember DefaultTesting IScopedOperations requesting requesting IID_IGetSourceRow int Variation_10(); // @cmember DefaultTesting ICreateRow requesting requesting IID_IGetSourceRow int Variation_11(); // }} TCW_TESTVARS_END } ; // {{ TCW_TESTCASE(TCIGetSourceRow_IUnknown) #define THE_CLASS TCIGetSourceRow_IUnknown BEG_TEST_CASE(TCIGetSourceRow_IUnknown, TCIGetSourceRow, L"Test IUnknown") TEST_VARIATION(1, L"DefaultTesting IBindResource") TEST_VARIATION(2, L"DefaultTesting IRow_Open from GetRow") TEST_VARIATION(3, L"DefaultTesting IScopedOperations") TEST_VARIATION(4, L"DefaultTesting ICreateRow") TEST_VARIATION(5, L"DefaultTesting Session IBindResource") TEST_VARIATION(8, L"DefaultTesting Session ICreateRow") TEST_VARIATION(9, L"DefaultTesting IRow_GetColumns") TEST_VARIATION(10, L"DefaultTesting IScopedOperations requesting requesting IID_IGetSourceRow") TEST_VARIATION(11, L"DefaultTesting ICreateRow requesting requesting IID_IGetSourceRow") END_TEST_CASE() #undef THE_CLASS // }} TCW_TESTCASE_END // }} TCW_TEST_CASE_MAP_END // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Test Case Section // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // {{ TCW_TEST_CASE_MAP(TCIGetSourceRow_GetSourceRow) //-------------------------------------------------------------------- // @class Test GetSourceRow method // class TCIGetSourceRow_GetSourceRow : public TCIGetSourceRow { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(TCIGetSourceRow_GetSourceRow,TCIGetSourceRow); // }} TCW_DECLARE_FUNCS_END // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember IRow_Open riid all Mandatory interfaces int Variation_1(); // @cmember IBindResource riid all Mandatory interfaces int Variation_2(); // @cmember ICreateRow riid all Mandatory interfaces int Variation_3(); // @cmember IScopedOperations riid all Mandatory interfaces int Variation_4(); // @cmember NULL ppIRow int Variation_5(); // @cmember IRow from ICommand riid all Mandatory Interfaces int Variation_7(); // @cmember IRow from IOpenRwst riid all Mandatory Interfaces int Variation_8(); // @cmember Sequence - 2 streams from IRow_Open int Variation_9(); // @cmember Verify Stream addrefs parent row int Variation_12(); // @cmember Mutliple open Row objects int Variation_13(); // @cmember Agg Stream int Variation_14(); // @cmember Agg Row A, unagg Stream int Variation_15(); // @cmember Agg Row A, unagg Stream, release source Row int Variation_16(); // @cmember Agg Row A, agg Stream B int Variation_17(); // @cmember Threads GetSourceRow int Variation_18(); // @cmember Session IBindResource riid all Mandatory interfaces int Variation_19(); // @cmember Session ICreateRow riid all Mandatory interfaces int Variation_20(); // @cmember IRow from ICommand Open Stream using GetColumns int Variation_21(); // @cmember IRow from IOpenRowset Open Stream using GetColumns int Variation_22(); // @cmember IRow from IGetRow Open Stream using GetColumns int Variation_23(); // @cmember IRow from IBindResource Open Stream using GetColumns int Variation_24(); // @cmember Threads, row from IGetRow, streams from GetColumns int Variation_25(); // @cmember Empty int Variation_26(); // @cmember Empty int Variation_27(); // @cmember Sequence - Multiple streams from IRow_GetColumns int Variation_28(); // @cmember Sequence - Multiple streams from IRow_Open and IRowGetColumns int Variation_29(); // @cmember Call GetSourceRow on stream whose parent is a rowset int Variation_30(); // @cmember Call GetSourceRow after SetColumns int Variation_31(); // }} TCW_TESTVARS_END }; // {{ TCW_TESTCASE(TCIGetSourceRow_GetSourceRow) #define THE_CLASS TCIGetSourceRow_GetSourceRow BEG_TEST_CASE(TCIGetSourceRow_GetSourceRow, TCIGetSourceRow, L"Test GetSourceRow method") TEST_VARIATION(1, L"IRow_Open riid all Mandatory interfaces") TEST_VARIATION(2, L"IBindResource riid all Mandatory interfaces") TEST_VARIATION(3, L"ICreateRow riid all Mandatory interfaces") TEST_VARIATION(4, L"IScopedOperations riid all Mandatory interfaces") TEST_VARIATION(5, L"NULL ppIRow") TEST_VARIATION(7, L"IRow from ICommand riid all Mandatory Interfaces") TEST_VARIATION(8, L"IRow from IOpenRwst riid all Mandatory Interfaces") TEST_VARIATION(9, L"Sequence - 2 streams from IRow_Open") TEST_VARIATION(12, L"Verify Stream addrefs parent row") TEST_VARIATION(13, L"Mutliple open Row objects") TEST_VARIATION(14, L"Agg Stream") TEST_VARIATION(15, L"Agg Row A, unagg Stream") TEST_VARIATION(16, L"Agg Row A, unagg Stream, release source Row") TEST_VARIATION(17, L"Agg Row A, agg Stream B") TEST_VARIATION(18, L"Threads GetSourceRow") TEST_VARIATION(19, L"Session IBindResource riid all Mandatory interfaces") TEST_VARIATION(20, L"Session ICreateRow riid all Mandatory interfaces") TEST_VARIATION(21, L"IRow from ICommand Open Stream using GetColumns") TEST_VARIATION(22, L"IRow from IOpenRowset Open Stream using GetColumns") TEST_VARIATION(23, L"IRow from IGetRow Open Stream using GetColumns") TEST_VARIATION(24, L"IRow from IBindResource Open Stream using GetColumns") TEST_VARIATION(25, L"Threads, row from IGetRow, streams from GetColumns") TEST_VARIATION(26, L"Empty") TEST_VARIATION(27, L"Empty") TEST_VARIATION(28, L"Sequence - Multiple streams from IRow_GetColumns") TEST_VARIATION(29, L"Sequence - Multiple streams from IRow_Open and IRowGetColumns") TEST_VARIATION(30, L"Call GetSourceRow on stream whose parent is a rowset") TEST_VARIATION(31, L"GetSourceRow after SetColumns") END_TEST_CASE() #undef THE_CLASS // }} TCW_TESTCASE_END // }} TCW_TEST_CASE_MAP_END // {{ TCW_TESTMODULE(ThisModule) TEST_MODULE(2, ThisModule, gwszModuleDescrip) TEST_CASE(1, TCIGetSourceRow_IUnknown) TEST_CASE(2, TCIGetSourceRow_GetSourceRow) END_TEST_MODULE() // }} TCW_TESTMODULE_END // {{ TCW_TC_PROTOTYPE(TCIGetSourceRow_IUnknown) //*----------------------------------------------------------------------- //| Test Case: TCIGetSourceRow_IUnknown - Test IUnknown //| Created: 10/4/98 //*----------------------------------------------------------------------- //*----------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL TCIGetSourceRow_IUnknown::Init() { // {{ TCW_INIT_BASECLASS_CHECK if(TCIGetSourceRow::Init()) // }} { // TO DO: Add your own code here return TRUE; } return FALSE; } // {{ TCW_VAR_PROTOTYPE(1) //*----------------------------------------------------------------------- // @mfunc DefaultTesting IBindResource // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_1() { BOOL fPass = TEST_FAIL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; TESTC_(StreamObject.InitStreamObject(m_pIBindResource, pwszURL), S_OK); fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); CLEANUP: return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(2) //*----------------------------------------------------------------------- // @mfunc DefaultTesting IRow_Open from GetRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_2() { BOOL fPass = TEST_FAIL; HRESULT hr; CStreamObject StreamObject; // Get stream using IRow::Open on the default stream TEST2C_(hr = StreamObject.InitStreamObject(m_pCRowObject->pIRow()), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); else fPass = TEST_SKIPPED; CLEANUP: return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(3) //*----------------------------------------------------------------------- // @mfunc DefaultTesting IScopedOperations // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_3() { BOOL fPass = TEST_FAIL; CStreamObject StreamObject; IScopedOperations * pIScopedOperations = NULL; if(!VerifyInterface(m_pCRowObject->pIRow(), IID_IScopedOperations, ROW_INTERFACE,(IUnknown**)&pIScopedOperations)) return TEST_SKIPPED; TESTC_(StreamObject.InitStreamObject(pIScopedOperations), S_OK); fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); CLEANUP: SAFE_RELEASE(pIScopedOperations); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(4) //*----------------------------------------------------------------------- // @mfunc DefaultTesting ICreateRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_4() { HRESULT hr; BOOL fPass = TEST_FAIL; CStreamObject StreamObject; ICreateRow * pICreateRow = NULL; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; StreamObject.SetBindURLFlags(DBBINDURLFLAG_OPENIFEXISTS | DBBINDURLFLAG_READ); if(!VerifyInterface(m_pIBindResource, IID_ICreateRow, BINDER_INTERFACE,(IUnknown**)&pICreateRow)) return TEST_SKIPPED; TEST2C_(hr = StreamObject.InitStreamObject(pICreateRow, pwszURL), S_OK, E_NOINTERFACE); if( hr == S_OK ) fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pICreateRow); return fPass; } // }} // {{ TCW_VAR_PROTOTYPE(5) //*----------------------------------------------------------------------- // @mfunc DefaultTesting Session IBindResource // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_5() { BOOL fPass = TEST_FAIL; IBindResource * pIBindResource = NULL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( E_NOINTERFACE == GetSessionObject(IID_IBindResource, (IUnknown **)&pIBindResource) ) return TEST_SKIPPED; if( !pwszURL ) return TEST_SKIPPED; TESTC_(StreamObject.InitStreamObject(pIBindResource, pwszURL), S_OK); fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); CLEANUP: SAFE_RELEASE(pIBindResource); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(8) //*----------------------------------------------------------------------- // @mfunc DefaultTesting Session ICreateRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_8() { BOOL fPass = TEST_FAIL; ICreateRow * pICreateRow = NULL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( E_NOINTERFACE == GetSessionObject(IID_ICreateRow, (IUnknown **)&pICreateRow) ) return TEST_SKIPPED; if( !pwszURL ) return TEST_SKIPPED; StreamObject.SetBindURLFlags(DBBINDURLFLAG_OPENIFEXISTS | DBBINDURLFLAG_READ); TESTC_(StreamObject.InitStreamObject(pICreateRow, pwszURL), S_OK); fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); CLEANUP: SAFE_RELEASE(pICreateRow); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(9) //*----------------------------------------------------------------------- // @mfunc DefaultTesting IRow_GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_9() { HRESULT hr; BOOL fPass = TEST_FAIL; CStreamObject StreamObject; TEST3C_(hr = StreamObject.InitStreamObject(m_pCRowObject->pIRow(), NULL), S_OK, E_NOINTERFACE, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC(DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE)); } else { TWARNING(L"IGetSourceRow was not available on this object"); } fPass = TEST_PASS; CLEANUP: return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(10) //*----------------------------------------------------------------------- // @mfunc DefaultTesting IScopedOperations requesting requesting IID_IGetSourceRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_10() { BOOL fPass = TEST_FAIL; CStreamObject StreamObject; IScopedOperations * pIScopedOperations = NULL; if(!VerifyInterface(m_pCRowObject->pIRow(), IID_IScopedOperations, ROW_INTERFACE,(IUnknown**)&pIScopedOperations)) return TEST_SKIPPED; TESTC_(StreamObject.InitStreamObject(pIScopedOperations, IID_IGetSourceRow), S_OK); fPass = DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE); CLEANUP: SAFE_RELEASE(pIScopedOperations); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(11) //*----------------------------------------------------------------------- // @mfunc DefaultTesting ICreateRow requesting requesting IID_IGetSourceRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_IUnknown::Variation_11() { HRESULT hr; BOOL fPass = TEST_FAIL; CStreamObject StreamObject; ICreateRow * pICreateRow = NULL; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); StreamObject.SetBindURLFlags(DBBINDURLFLAG_OPENIFEXISTS | DBBINDURLFLAG_READ); if(!VerifyInterface(m_pCRowObject->pIRow(), IID_ICreateRow, BINDER_INTERFACE,(IUnknown**)&pICreateRow)) return TEST_SKIPPED; if( !pwszURL ) return TEST_SKIPPED; TEST2C_(hr = StreamObject.InitStreamObject(pICreateRow, pwszURL, IID_IStream), S_OK, E_NOINTERFACE); if( hr == S_OK ) { TESTC(DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE)); } StreamObject.ReleaseStreamObject(); TEST2C_(hr = StreamObject.InitStreamObject(pICreateRow, pwszURL, IID_IGetSourceRow), S_OK, E_NOINTERFACE); if( hr == S_OK ) { TESTC(DefaultObjectTesting(StreamObject.pIGetSourceRow(), STREAM_INTERFACE)); fPass = TEST_PASS; } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pICreateRow); return fPass; } // }} // {{ TCW_TERMINATE_METHOD //*----------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TEST_PASS or TEST_FAIL // BOOL TCIGetSourceRow_IUnknown::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 return(TCIGetSourceRow::Terminate()); } // }} // }} TCW_TERMINATE_METHOD_END // }} TCW_TC_PROTOTYPE_END // {{ TCW_TC_PROTOTYPE(TCIGetSourceRow_GetSourceRow) //*----------------------------------------------------------------------- //| Test Case: TCIGetSourceRow_GetSourceRow - Test GetSourceRow method //| Created: 10/11/98 //*----------------------------------------------------------------------- //-------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL TCIGetSourceRow_GetSourceRow::Init() { // {{ TCW_INIT_BASECLASS_CHECK if(TCIGetSourceRow::Init()) // }} { // TO DO: Add your own code here return TRUE; } return FALSE; } // {{ TCW_VAR_PROTOTYPE(1) //*----------------------------------------------------------------------- // @mfunc IRow_Open riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_1() { HRESULT hr; CStreamObject StreamObject; // Open using IRow::Open on the default stream TEST2C_(hr = StreamObject.InitStreamObject(m_pCRowObject->pIRow()), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC_(TestGetSourceRow(&StreamObject), S_OK); } else return TEST_SKIPPED; CLEANUP: return TEST_PASS; } // }} // {{ TCW_VAR_PROTOTYPE(2) //*----------------------------------------------------------------------- // @mfunc IBindResource riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_2() { HRESULT hr; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; TESTC_(hr = StreamObject.InitStreamObject(m_pIBindResource, pwszURL), S_OK); TESTC_(hr = TestGetSourceRow(&StreamObject), S_OK); CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(3) //*----------------------------------------------------------------------- // @mfunc ICreateRow riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_3() { HRESULT hr; BOOL fPass = TEST_FAIL; ICreateRow * pICreateRow = NULL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; StreamObject.SetBindURLFlags(DBBINDURLFLAG_OPENIFEXISTS | DBBINDURLFLAG_READ); TESTC(VerifyInterface(m_pIBindResource, IID_ICreateRow, STREAM_INTERFACE,(IUnknown**)&pICreateRow)) TEST2C_(hr = StreamObject.InitStreamObject(pICreateRow, pwszURL), S_OK, E_NOINTERFACE); if( S_OK == hr ) { TESTC_(TestGetSourceRow(&StreamObject), S_OK); fPass = TEST_PASS; } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pICreateRow); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(4) //*----------------------------------------------------------------------- // @mfunc IScopedOperations riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_4() { CStreamObject StreamObject; IScopedOperations * pIScopedOperations = NULL; if(!VerifyInterface(m_pCRowObject->pIRow(), IID_IScopedOperations, ROW_INTERFACE,(IUnknown**)&pIScopedOperations)) return TEST_SKIPPED; TESTC_(StreamObject.InitStreamObject(pIScopedOperations), S_OK); TESTC_(TestGetSourceRow(&StreamObject), S_OK); CLEANUP: SAFE_RELEASE(pIScopedOperations); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(5) //*----------------------------------------------------------------------- // @mfunc NULL ppIRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_5() { HRESULT hr = S_OK; CStreamObject StreamObject; TEST2C_(hr = StreamObject.InitStreamObject(m_pCRowObject->pIRow()), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC_(hr = StreamObject.GetSourceRow(IID_IUnknown, NULL), E_INVALIDARG); } else return TEST_SKIPPED; CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(7) //-------------------------------------------------------------------- // @mfunc IRow from ICommand riid all Mandatory Interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_7() { CRowset RowsetA; CRowObject RowObjectA; CStreamObject StreamObjectA; IRow * pIRow = NULL; HRESULT hr; BOOL fPass = TEST_PASS; //Create a row object from ICommand::Execute TEST2C_(RowsetA.pTable()->CreateRowset(SELECT_ALLFROMTBL, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, DB_S_NOTSINGLETON); TESTC_(RowObjectA.SetRowObject(pIRow),S_OK); TEST2C_(hr = StreamObjectA.InitStreamObject(pIRow), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); TESTC(DefaultObjectTesting(StreamObjectA.pIGetSourceRow(), STREAM_INTERFACE)); } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pIRow); return fPass; } // }} // {{ TCW_VAR_PROTOTYPE(8) //-------------------------------------------------------------------- // @mfunc IRow from IOpenRwst riid all Mandatory Interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_8() { CRowset RowsetA; CRowObject RowObjectA; CStreamObject StreamObjectA; IRow * pIRow = NULL; HRESULT hr; BOOL fPass = TEST_PASS; //Create a row object from IOpenRowset TEST2C_(RowsetA.pTable()->CreateRowset(USE_OPENROWSET, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, DB_S_NOTSINGLETON); TESTC_(RowObjectA.SetRowObject(pIRow),S_OK); TEST2C_(hr = StreamObjectA.InitStreamObject(pIRow), S_OK, DB_E_BADCOLUMNID); if( SUCCEEDED(hr) ) { TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); TESTC(DefaultObjectTesting(StreamObjectA.pIGetSourceRow(), STREAM_INTERFACE)); } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pIRow); return fPass; } // }} // {{ TCW_VAR_PROTOTYPE(9) //*----------------------------------------------------------------------- // @mfunc Sequence - 2 streams from IRow_Open // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_9() { const ULONG cStreamObjects = 20; TESTC_(TestMultipleStreams(cStreamObjects, EROWOPEN), S_OK); CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(12) //*----------------------------------------------------------------------- // @mfunc Verify Stream addrefs parent row // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_12() { IUnknown * pIUnknown = NULL; IRow * pIRow = NULL; CStreamObject StreamObjectA; HRESULT hr; BOOL fPass = TEST_PASS; TEST2C_(hr = BindRow(NULL, (IUnknown **)&pIUnknown), S_OK, S_FALSE); if( hr == S_OK ) { TESTC(VerifyInterface(pIUnknown, IID_IRow, ROW_INTERFACE,(IUnknown**)&pIRow)) TESTC_(StreamObjectA.InitStreamObject(pIRow), S_OK); SAFE_RELEASE(pIUnknown); SAFE_RELEASE(pIRow); TESTC_(StreamObjectA.GetSourceRow(IID_IRow, (IUnknown **)&pIRow), S_OK); TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); TESTC(DefaultObjectTesting(StreamObjectA.pIGetSourceRow(), STREAM_INTERFACE)); } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pIUnknown); SAFE_RELEASE(pIRow); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(13) //*----------------------------------------------------------------------- // @mfunc Mutliple open Row objects // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_13() { const ULONG cOpenRows = 5; CRowset RowsetA; CRowObject RowObjects[cOpenRows]; CStreamObject StreamObjects[cOpenRows]; HRESULT hr = S_OK; IUnknown * pIRow = NULL; ULONG cRowsObtained = 0; ULONG i = 0; HROW rghRows[cOpenRows]; HROW hRow = NULL; if( (m_ulpOleObjects & DBPROPVAL_OO_ROWOBJECT) == 0) return TEST_SKIPPED; //Create RowsetA //May require IRowsetLocate to position on Blobs RowsetA.SetSettableProperty(DBPROP_IRowsetLocate); TESTC_(RowsetA.CreateRowset(DBPROP_CANHOLDROWS),S_OK); //Create Row objects from the a set of rows belonging to same rowset for(i=0; ipIRow()->Open(&Aggregate, &dbid, DBGUID_STREAM, 0, IID_IUnknown, &pUnkInner); if( DB_E_BADCOLUMNID == hr ) return TEST_SKIPPED; Aggregate.SetUnkInner(pUnkInner); if(Aggregate.VerifyAggregationQI(hr, IID_IGetSourceRow, (IUnknown**)&pIGetSourceRow)) { TESTC_(StreamObject.SetStreamObject(pIGetSourceRow), S_OK); TESTC_(TestGetSourceRow(&StreamObject), S_OK); } CLEANUP: SAFE_RELEASE(pUnkInner); SAFE_RELEASE(pIGetSourceRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(15) //*----------------------------------------------------------------------- // @mfunc Agg Row A, unagg Stream // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_15() { HRESULT hr; IRow * pIRow = NULL; IUnknown * pIUnknown = NULL; IUnknown * pUnkInner = NULL; CAggregate Aggregate(m_pIBindResource); CStreamObject StreamObjectA; hr = BindRow(&Aggregate, &pUnkInner); if( S_FALSE == hr ) return TEST_SKIPPED; Aggregate.SetUnkInner(pUnkInner); if(Aggregate.VerifyAggregationQI(hr, IID_IRow, (IUnknown**)&pIRow)) { TESTC_(StreamObjectA.InitStreamObject(pIRow), S_OK); TESTC_(hr = StreamObjectA.pIGetSourceRow()->GetSourceRow(IID_IAggregate, &pIUnknown), S_OK); TESTC(VerifyEqualInterface(pIUnknown, pIRow)); TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); TESTC(DefaultObjectTesting(StreamObjectA.pIGetSourceRow(), STREAM_INTERFACE)); } CLEANUP: SAFE_RELEASE(pUnkInner); SAFE_RELEASE(pIUnknown); SAFE_RELEASE(pIRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(16) //*----------------------------------------------------------------------- // @mfunc Agg Row A, unagg Stream, release source Row // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_16() { HRESULT hr = E_FAIL; IRow * pIRow = NULL; IUnknown * pUnkInner = NULL; CAggregate Aggregate(m_pIBindResource); CStreamObject StreamObjectA; hr = BindRow(&Aggregate, &pUnkInner); if( S_FALSE == hr ) return TEST_SKIPPED; Aggregate.SetUnkInner(pUnkInner); if(Aggregate.VerifyAggregationQI(hr, IID_IRow, (IUnknown**)&pIRow)) { TESTC_(StreamObjectA.InitStreamObject(pIRow), S_OK); SAFE_RELEASE(pIRow); TESTC(Aggregate.Release() > 0); hr = TestGetSourceRow(&StreamObjectA); Aggregate.AddRef(); } else hr = S_OK; CLEANUP: SAFE_RELEASE(pUnkInner); SAFE_RELEASE(pIRow); return ( S_OK == hr ); } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(17) //*----------------------------------------------------------------------- // @mfunc Agg Row A, agg Stream B // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_17() { HRESULT hr; IRow * pIRow = NULL; IUnknown * pRowUnkInner = NULL; IUnknown * pStreamUnkInner = NULL; IGetSourceRow * pIGetSourceRow = NULL; DBID dbid = DBROWCOL_DEFAULTSTREAM; CAggregate AggregateRow(m_pIBindResource); CAggregate AggregateStream(m_pIBindResource); CStreamObject StreamObjectA; hr = BindRow(&AggregateRow, &pRowUnkInner); if( S_FALSE == hr ) return TEST_SKIPPED; AggregateRow.SetUnkInner(pRowUnkInner); if(AggregateRow.VerifyAggregationQI(hr, IID_IRow, (IUnknown**)&pIRow)) { hr = pIRow->Open(&AggregateStream, &dbid, DBGUID_STREAM, 0, IID_IUnknown, &pStreamUnkInner); AggregateStream.SetUnkInner(pStreamUnkInner); TESTC(AggregateStream.VerifyAggregationQI(hr, IID_IGetSourceRow, (IUnknown**)&pIGetSourceRow)); TESTC_(StreamObjectA.SetStreamObject(pIGetSourceRow), S_OK); TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); } CLEANUP: SAFE_RELEASE(pRowUnkInner); SAFE_RELEASE(pStreamUnkInner); SAFE_RELEASE(pIRow); SAFE_RELEASE(pIGetSourceRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(18) //*----------------------------------------------------------------------- // @mfunc Threads GetSourceRow // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_18() { HRESULT hr; BOOL fPass = TEST_PASS; INIT_THREADS(MAX_THREADS); //Setup Thread Arguments THREADARG T1Arg = { this }; //Setup Stream object TEST2C_(hr = m_pCStreamObject->InitStreamObject(m_pCRowObject->pIRow()), S_OK, DB_E_BADCOLUMNID); if( S_OK == hr ) { //Create Threads CREATE_THREADS(Thread_VerifyGetSourceRow, &T1Arg); START_THREADS(); END_THREADS(); } else fPass = TEST_SKIPPED; CLEANUP: m_pCStreamObject->ReleaseStreamObject(); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(19) //*----------------------------------------------------------------------- // @mfunc Session IBindResource riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_19() { HRESULT hr; IBindResource * pIBindResource = NULL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; if( E_NOINTERFACE == GetSessionObject(IID_IBindResource, (IUnknown **)&pIBindResource)) return TEST_SKIPPED; TESTC_(hr = StreamObject.InitStreamObject(pIBindResource, pwszURL), S_OK); TESTC_(hr = TestGetSourceRow(&StreamObject), S_OK); CLEANUP: SAFE_RELEASE(pIBindResource); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(20) //*----------------------------------------------------------------------- // @mfunc Session ICreateRow riid all Mandatory interfaces // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_20() { HRESULT hr; ICreateRow * pICreateRow = NULL; CStreamObject StreamObject; WCHAR * pwszURL = GetModInfo()->GetParseObject()->GetURL(STREAM_INTERFACE); if( !pwszURL ) return TEST_SKIPPED; if( E_NOINTERFACE == GetSessionObject(IID_ICreateRow, (IUnknown **)&pICreateRow)) return TEST_SKIPPED; StreamObject.SetBindURLFlags(DBBINDURLFLAG_OPENIFEXISTS | DBBINDURLFLAG_READ); TESTC_(hr = StreamObject.InitStreamObject(pICreateRow, pwszURL), S_OK); TESTC_(hr = TestGetSourceRow(&StreamObject), S_OK); CLEANUP: SAFE_RELEASE(pICreateRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(21) //*----------------------------------------------------------------------- // @mfunc IRow from ICommand Open Stream using GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_21() { CRowset RowsetA; CRowObject RowObjectA; IRow * pIRow = NULL; //Create a row object from ICommand::Execute TEST2C_(RowsetA.pTable()->CreateRowset(SELECT_ALLFROMTBL, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, DB_S_NOTSINGLETON); TESTC_(RowObjectA.SetRowObject(pIRow),S_OK); TESTC(VerifyBLOBSFromRowObject(&RowObjectA)); CLEANUP: SAFE_RELEASE(pIRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(22) //*----------------------------------------------------------------------- // @mfunc IRow from IOpenRowset Open Stream using GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_22() { CRowset RowsetA; CRowObject RowObjectA; IRow * pIRow = NULL; //Create a row object from IOpenRowset TEST2C_(RowsetA.pTable()->CreateRowset(USE_OPENROWSET, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, DB_S_NOTSINGLETON); TESTC_(RowObjectA.SetRowObject(pIRow),S_OK); TESTC(VerifyBLOBSFromRowObject(&RowObjectA)); CLEANUP: SAFE_RELEASE(pIRow); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(23) //*----------------------------------------------------------------------- // @mfunc IRow from IGetRow Open Stream using GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_23() { CRowObject RowObjectA; TESTC_(RowObjectA.SetRowObject(m_pCRowObject->pIRow()),S_OK); TESTC(VerifyBLOBSFromRowObject(&RowObjectA)); CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(24) //*----------------------------------------------------------------------- // @mfunc IRow from IBindResource Open Stream using GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_24() { CRowObject RowObjectA; IUnknown * pUnk = NULL; IRow * pIRow = NULL; HRESULT hr; BOOL fPass = TEST_PASS; TEST2C_(hr = BindRow(NULL, (IUnknown **)&pUnk), S_OK, S_FALSE); if( hr == S_OK ) { TESTC(VerifyInterface(pUnk, IID_IRow, ROW_INTERFACE,(IUnknown**)&pIRow)) TESTC_(RowObjectA.SetRowObject(pIRow),S_OK); TESTC(VerifyBLOBSFromRowObject(&RowObjectA)); } else fPass = TEST_SKIPPED; CLEANUP: SAFE_RELEASE(pUnk); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(25) //*----------------------------------------------------------------------- // @mfunc Threads, row from IGetRow, streams from GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_25() { INIT_THREADS(MAX_THREADS); HRESULT hr; CStreamObject StreamObjectA; hr = StreamObjectA.InitStreamUsingGetColumns(m_pCRowObject->pIRow()); if( FAILED(hr)) { if( E_NOINTERFACE == hr ) return TEST_SKIPPED; else return TEST_FAIL; } //Setup Thread Arguments THREADARG T1Arg = { this, &StreamObjectA }; //Create Threads CREATE_THREADS(Thread_GetColumns_VerifyGetSourceRow, &T1Arg); START_THREADS(); END_THREADS(); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(26) //*----------------------------------------------------------------------- // @mfunc Empty // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_26() { TBEGIN HRESULT hr; HROW hRow = DB_NULL_HROW; CRowset RowsetA; CRowObject RowObjectA; CStreamObject StreamObjectA; CStreamObject StreamObjectB; if( (m_ulpOleObjects & DBPROPVAL_OO_ROWOBJECT) == 0) return TEST_SKIPPED; //Use a new rowset, and ask for a non-forward-only cursor, //so we can obtain the data multiple times. RowsetA.SetSettableProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET); TESTC_(RowsetA.CreateRowset(), S_OK); TESTC_(RowsetA.GetNextRows(&hRow),S_OK); //Now create the row object. TEST2C_(RowObjectA.CreateRowObject(RowsetA.pIRowset(), hRow), S_OK, DB_S_NOROWSPECIFICCOLUMNS); TEST2C_(hr = StreamObjectA.InitStreamUsingGetColumns(RowObjectA.pIRow()), S_OK, E_NOINTERFACE); TEST2C_(hr = StreamObjectB.InitStreamUsingGetColumns(RowObjectA.pIRow()), S_OK, E_NOINTERFACE); if( S_OK == hr ) { // Release the Row Object RowObjectA.ReleaseRowObject(); TESTC_(TestGetSourceRow(&StreamObjectA), S_OK); StreamObjectA.ReleaseStreamObject(); TESTC_(TestGetSourceRow(&StreamObjectB), S_OK); } CLEANUP: RowsetA.ReleaseRows(hRow); TRETURN } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(27) //*----------------------------------------------------------------------- // @mfunc Empty // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_27() { INIT_THREADS(2); HRESULT hr; HROW hRow = DB_NULL_HROW; CRowset RowsetA; CRowObject RowObjectA; CStreamObject StreamObjectA; if( (m_ulpOleObjects & DBPROPVAL_OO_ROWOBJECT) == 0) return TEST_SKIPPED; //Use a new rowset, and ask for a non-forward-only cursor, //so we can obtain the data multiple times. RowsetA.SetSettableProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET); TESTC_(RowsetA.CreateRowset(), S_OK); TESTC_(RowsetA.GetNextRows(&hRow),S_OK); //Now create the row object. TEST2C_(RowObjectA.CreateRowObject(RowsetA.pIRowset(), hRow), S_OK, DB_S_NOROWSPECIFICCOLUMNS); TEST2C_(hr = StreamObjectA.InitStreamUsingGetColumns(RowObjectA.pIRow()), S_OK, E_NOINTERFACE); RowObjectA.ReleaseRowObject(); if( S_OK == hr ) { //Setup Thread Arguments THREADARG T1Arg = { this, &StreamObjectA }; THREADARG T2Arg = { &RowsetA, &hRow}; //Create Threads CREATE_FIRST_THREADS(Thread_GetColumns_VerifyGetSourceRow, &T1Arg); CREATE_SECOND_THREADS(Thread_ReleaseRow, &T2Arg); START_THREADS(); END_THREADS(); } CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(28) //*----------------------------------------------------------------------- // @mfunc Sequence - Multiple streams from IRow_GetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_28() { const ULONG cStreamObjects = 20; TESTC_(TestMultipleStreams(cStreamObjects, EROWGETCOL), S_OK); CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(29) //*----------------------------------------------------------------------- // @mfunc Sequence - Multiple streams from IRow_Open and IRowGetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_29() { const ULONG cStreamObjects = 20; TESTC_(TestMultipleStreams(cStreamObjects, EROWBOTH), S_OK); CLEANUP: return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(30) //*----------------------------------------------------------------------- // @mfunc Call GetSourceRow on stream whose parent is a rowset // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_30() { HRESULT hr; HROW hRow = DB_NULL_HROW; CRowset RowsetA; HACCESSOR hAccessor = DB_NULL_HACCESSOR; void * pData = NULL; ULONG_PTR cBytes = 0; DBCOUNTITEM cBindings = 0; DBBINDING * rgBindings = NULL; IUnknown * pUnkStorage = NULL; IGetSourceRow * pIGetSourceRow = NULL; if( (m_ulpOleObjects & DBPROPVAL_OO_ROWOBJECT) == 0) return TEST_SKIPPED; RowsetA.SetSettableProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET); TESTC_(RowsetA.CreateRowset(), S_OK); TESTC_(RowsetA.GetNextRows(&hRow),S_OK); //Create Accessor binding BLOB/Storage Object data TESTC_(RowsetA.CreateAccessor(&hAccessor, DBACCESSOR_ROWDATA, DBPART_ALL, &cBindings, &rgBindings, &cBytes, BLOB_IID_ISEQSTREAM), S_OK) //Alloc buffers SAFE_ALLOC(pData, void*, cBytes); //Get the Data TESTC_(hr = RowsetA.pIRowset()->GetData(hRow, hAccessor, pData), S_OK) //Display any binding errors and status' TESTC(VerifyBindings(hr, RowsetA.pIAccessor(), hAccessor, pData)); if( GetStorageObject(cBindings, rgBindings, pData, IID_ISequentialStream, (IUnknown **)&pUnkStorage) ) { if( S_OK == pUnkStorage->QueryInterface(IID_IGetSourceRow, (void **)&pIGetSourceRow) ) { IUnknown * pUnkSource = NULL; // Provider may choose to allow all storage objects to support IGetSourceRow. // However, if a storage object's parent was a rowset instead of row, they should // return DB_E_NOSOURCEOBJECT. TESTC(pIGetSourceRow != NULL); TESTC_(pIGetSourceRow->GetSourceRow(IID_IUnknown, &pUnkSource), DB_E_NOSOURCEOBJECT); SAFE_RELEASE(pUnkSource); } } CLEANUP: SAFE_RELEASE(pIGetSourceRow); SAFE_RELEASE(pUnkStorage); SAFE_FREE(pData); return TEST_PASS; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_VAR_PROTOTYPE(31) //*----------------------------------------------------------------------- // @mfunc Call GetSourceRow after IRow::SetColumns // // @rdesc TEST_PASS or TEST_FAIL // int TCIGetSourceRow_GetSourceRow::Variation_31() { HRESULT hr; BOOL fPass = TEST_FAIL; HROW hRow = DB_NULL_HROW; CRowset RowsetA; CRowObject RowObjectA; CStreamObject StreamObjectA; DBCOUNTITEM cColAccess = 0; DBCOLUMNACCESS * rgColAccess = NULL; void * pData = NULL; ULONG_PTR cbRowSize = 0; IRow * pIRow = NULL; DBCOUNTITEM ulChangeSeed; if( (m_ulpOleObjects & DBPROPVAL_OO_ROWOBJECT) == 0) return TEST_SKIPPED; //Use a new rowset, and ask for an updatable cursor, //so we can update the data RowsetA.SetSettableProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET); RowsetA.SetSettableProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET); TESTC_(RowsetA.CreateRowset(), S_OK); ulChangeSeed = RowsetA.GetTotalRows()+1; TESTC_(RowsetA.GetNextRows(&hRow),S_OK); //Now create the row object. TEST2C_(RowObjectA.CreateRowObject(RowsetA.pIRowset(), hRow), S_OK, DB_S_NOROWSPECIFICCOLUMNS); TEST2C_(hr = StreamObjectA.InitStreamUsingGetColumns(RowObjectA.pIRow()), S_OK, E_NOINTERFACE); TESTC_(RowsetA.ReleaseRows(hRow), S_OK); // Bind all BLOB columns TESTC_(RowObjectA.CreateColAccess(&cColAccess, &rgColAccess, &pData, &cbRowSize, BLOB_COLS_BOUND, BLOB_IID_ISEQSTREAM), S_OK); if( cColAccess == 0 ) { fPass = TEST_SKIPPED; goto CLEANUP; } TESTC_(RowObjectA.FillColAccess(RowsetA.pTable(), cColAccess, rgColAccess, ulChangeSeed), S_OK); TESTC_(RowObjectA.SetColumns(cColAccess, rgColAccess), S_OK) // Changing the streams may zombie the row TEST2C_(StreamObjectA.GetSourceRow(IID_IRow, (IUnknown **)&pIRow), S_OK, E_UNEXPECTED); SAFE_RELEASE(pIRow); // Release all Storage references and obtain a new one StreamObjectA.ReleaseStreamObject(); TEST2C_(hr = StreamObjectA.InitStreamUsingGetColumns(RowObjectA.pIRow()), S_OK, E_NOINTERFACE); TEST2C_(StreamObjectA.GetSourceRow(IID_IRow, (IUnknown **)&pIRow), S_OK, DB_E_NOSOURCEOBJECT); fPass = TEST_PASS; CLEANUP: SAFE_RELEASE(pIRow); FreeColAccess(cColAccess, rgColAccess); SAFE_FREE(pData); return fPass; } // }} TCW_VAR_PROTOTYPE_END // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL TCIGetSourceRow_GetSourceRow::Terminate() { // TO DO: Add your own code here // {{ TCW_TERM_BASECLASS_CHECK2 return(TCIGetSourceRow::Terminate()); } // }} // }} // }}