4753 lines
123 KiB
C++
4753 lines
123 KiB
C++
//*-----------------------------------------------------------------------
|
|
//
|
|
// Conformance Test for ICommandStream interface.
|
|
//
|
|
// WARNING:
|
|
// PLEASE USE THE TEST CASE WIZARD TO ADD/DELETE TESTS AND VARIATIONS!
|
|
//
|
|
//
|
|
// Copyright (C) 1994-2000 Microsoft Corporation
|
|
//*-----------------------------------------------------------------------
|
|
|
|
|
|
#include "MODStandard.hpp"
|
|
#include "ICmdStream.h"
|
|
#include "ExtraLib.h"
|
|
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// Module Values
|
|
//*-----------------------------------------------------------------------
|
|
// {{ TCW_MODULE_GLOBALS
|
|
DECLARE_MODULE_CLSID = { 0x58748a00, 0x8be4, 0x11d3, { 0x89, 0x4b, 0x00, 0x60, 0x08, 0x9f, 0xc4, 0x66} };
|
|
DECLARE_MODULE_NAME("ICommandStream");
|
|
DECLARE_MODULE_OWNER("Microsoft");
|
|
DECLARE_MODULE_DESCRIP("ICommandStream Test Module");
|
|
DECLARE_MODULE_VERSION(1);
|
|
// TCW_WizardVersion(2)
|
|
// TCW_Automation(FALSE)
|
|
// }} TCW_MODULE_GLOBALS_END
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//GLOBALS
|
|
///////////////////////////////////////////////////////////
|
|
GUID GUIDNULL = DB_NULLGUID;
|
|
WCHAR wszByteOrder[1] = {0xFEFF};
|
|
BOOL g_fSQLOLEDB = FALSE;
|
|
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// @func Module level initialization routine
|
|
//
|
|
// @rdesc Success or Failure
|
|
// @flag TRUE | Successful initialization
|
|
// @flag FALSE | Initialization problems
|
|
//
|
|
BOOL ModuleInit(CThisTestModule * pThisTestModule)
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR* wszProviderName = NULL;
|
|
IDBCreateCommand* pIDBCreateCommand = NULL;
|
|
ICommandStream* pICmdStream = NULL;
|
|
|
|
// Get connection and session objects
|
|
TESTC(ModuleCreateDBSession(pThisTestModule));
|
|
|
|
// IDBCreateCommand
|
|
TESTC_PROVIDER(VerifyInterface(pThisTestModule->m_pIUnknown2, IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand))
|
|
|
|
TEST2C_(hr = pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommandStream, (IUnknown**)&pICmdStream), S_OK, E_NOINTERFACE)
|
|
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
// Create a table and store it in pVoid for now
|
|
pThisTestModule->m_pVoid = new CTable(
|
|
(IUnknown *)pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
|
|
|
|
TESTC(pThisTestModule->m_pVoid != NULL);
|
|
|
|
// Start with a table with 10 rows
|
|
TESTC_(((CTable *)pThisTestModule->m_pVoid)->CreateTable(10), S_OK);
|
|
|
|
g_fSQLOLEDB=FALSE;
|
|
if (GetProperty(DBPROP_PROVIDERNAME, DBPROPSET_DATASOURCEINFO, pThisTestModule->m_pIUnknown, &wszProviderName)
|
|
&& wszProviderName)
|
|
{
|
|
if (!wcscmp((LPWSTR)wszProviderName, L"sqloledb.dll"))
|
|
g_fSQLOLEDB=TRUE;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(wszProviderName);
|
|
SAFE_RELEASE(pICmdStream);
|
|
SAFE_RELEASE(pIDBCreateCommand);
|
|
TRETURN
|
|
}
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// @func Module level termination routine
|
|
//
|
|
// @rdesc Success or Failure
|
|
// @flag TRUE | Successful initialization
|
|
// @flag FALSE | Initialization problems
|
|
//
|
|
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
|
|
{
|
|
// Drop the table created in the ModuleInit
|
|
if( pThisTestModule->m_pVoid )
|
|
{
|
|
// Remove table from database and Delete CTable object
|
|
((CTable *)pThisTestModule->m_pVoid)->DropTable();
|
|
delete ((CTable *)pThisTestModule->m_pVoid);
|
|
pThisTestModule->m_pVoid = NULL;
|
|
}
|
|
|
|
return ModuleReleaseDBSession(pThisTestModule);
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
// Base class for testing ICommandStream interface
|
|
//
|
|
///////////////////////////////////////////////////////////////
|
|
class CCmdStream : public CSessionObject
|
|
{
|
|
public:
|
|
|
|
// @cmember Constructor
|
|
CCmdStream(LPWSTR wszTestCaseName) : CSessionObject (wszTestCaseName)
|
|
{
|
|
m_pwszQ1 = NULL;
|
|
m_pwszQ2 = NULL;
|
|
m_pStorageGet = NULL;
|
|
m_pStorageSet = NULL;
|
|
m_pICommandText = NULL;
|
|
m_pICommandStream = NULL;
|
|
};
|
|
|
|
// @cmember Destructor
|
|
virtual ~CCmdStream() {};
|
|
|
|
protected:
|
|
|
|
//VARIABLES
|
|
|
|
//Storage object used for getting back cmd stream
|
|
CStorage* m_pStorageGet;
|
|
|
|
//Storage object used for setting cmd stream
|
|
CStorage* m_pStorageSet;
|
|
|
|
//Queries that will successfully Execute when set on
|
|
//ICommandStream with DBGUID_DEFAULT.
|
|
WCHAR* m_pwszQ1;
|
|
WCHAR* m_pwszQ2;
|
|
|
|
//INTERFACES
|
|
|
|
// @cmember ICommandText Interface pointer
|
|
ICommandText * m_pICommandText;
|
|
// @cmember ICommandText Interface pointer
|
|
ICommandStream * m_pICommandStream;
|
|
|
|
//FUNCTIONS
|
|
|
|
//@cmember Init
|
|
BOOL Init();
|
|
|
|
//@cmember Terminate
|
|
BOOL Terminate();
|
|
|
|
//Get the Queries.
|
|
BOOL GetQueries();
|
|
|
|
//Wrapper for ICommandStream::GetCommandStream.
|
|
HRESULT GetCmdStream(IID* piid, GUID* pguid, WCHAR** pwszCmd=NULL);
|
|
|
|
//Wrapper for ICommandStream::SetCommandStream.
|
|
HRESULT SetCmdStream(IID iid, GUID guid, WCHAR* pwszCmd=NULL);
|
|
|
|
//Reads the stream obtained by GetCommandStream, or
|
|
//pUnkStream. Reads as unicode.
|
|
HRESULT Read(WCHAR** ppwszCmd, IUnknown* pUnkStream=NULL);
|
|
|
|
//Write to the stream to be set using SetCommandStream.
|
|
HRESULT Write(WCHAR* pwszCmd);
|
|
|
|
//Prepare the command.
|
|
BOOL PrepCmd();
|
|
|
|
//Set a command property
|
|
HRESULT SetCmdProp(DBPROPSET* prgPropSet, IUnknown* pICmd=NULL);
|
|
|
|
//Default testing function for ICommandStream interface.
|
|
BOOL DefTest(ICommandStream* pICS);
|
|
|
|
//Verification function for rowsets.
|
|
BOOL VerifyRowset(EQUERY eQuery, IRowset* pIR);
|
|
|
|
//Verification function for m_pwszQ1.
|
|
BOOL VerifyQuery1(IUnknown* pIStream, REFIID riid);
|
|
|
|
//Verification function for m_pwszQ2.
|
|
BOOL VerifyQuery2(IUnknown* pIStream, REFIID riid);
|
|
|
|
BOOL GetAttrValue(IXMLDOMNode* pNode, WCHAR** ppwszName, WCHAR** ppwszVal);
|
|
|
|
BOOL QIDOMNode(IXMLDOMNode* pIn, IXMLDOMNode** pOut);
|
|
|
|
//Set a DBPROP_OUTPUTENCODING.
|
|
HRESULT SetEncdProp(ENCODING eOE, IUnknown* pICmd=NULL);
|
|
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::Init
|
|
//
|
|
BOOL CCmdStream::Init()
|
|
{
|
|
TBEGIN
|
|
|
|
TESTC(COLEDB::Init())
|
|
|
|
// Set needed pointers
|
|
SetDataSourceObject(m_pThisTestModule->m_pIUnknown, TRUE);
|
|
SetDBSession((IDBCreateCommand *)m_pThisTestModule->m_pIUnknown2);
|
|
SetTable((CTable *)(m_pThisTestModule->m_pVoid), DELETETABLE_NO);
|
|
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommandStream, (IUnknown**)&m_pICommandStream), S_OK)
|
|
TESTC(VerifyInterface(m_pICommandStream,
|
|
IID_ICommandText, COMMAND_INTERFACE,(IUnknown **)&m_pICommandText))
|
|
|
|
TESTC(GetQueries())
|
|
|
|
CHECK(SetEncdProp(UTF16), S_OK);
|
|
|
|
CLEANUP:
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::Terminate
|
|
//
|
|
BOOL CCmdStream::Terminate()
|
|
{
|
|
// Release objects
|
|
SAFE_FREE(m_pwszQ1);
|
|
SAFE_FREE(m_pwszQ2);
|
|
SAFE_RELEASE(m_pStorageGet);
|
|
SAFE_RELEASE(m_pStorageSet);
|
|
SAFE_RELEASE(m_pICommandText);
|
|
SAFE_RELEASE(m_pICommandStream);
|
|
ReleaseDBSession();
|
|
ReleaseDataSourceObject();
|
|
|
|
return(COLEDB::Terminate());
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::GetQueries
|
|
//
|
|
BOOL CCmdStream::GetQueries()
|
|
{
|
|
TBEGIN
|
|
BOOL fRet = FALSE;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszCol = NULL;
|
|
CCol rgCol;
|
|
|
|
m_pwszQ1 = wcsDuplicate(GetModInfo()->GetParseObject()->GetQuery(SETCMDSTREAM_QUERY1));
|
|
m_pwszQ2 = wcsDuplicate(GetModInfo()->GetParseObject()->GetQuery(SETCMDSTREAM_QUERY2));
|
|
|
|
if(m_pwszQ1)
|
|
goto QUERY2;
|
|
|
|
TESTC_(m_pTable->GetColInfo(1, rgCol), S_OK)
|
|
pwszCol = rgCol.GetColName();
|
|
|
|
SAFE_ALLOC(pwszSQL, WCHAR, (sizeof(WCHAR) *
|
|
(wcslen(wszSELECT_COLLISTFROMTBL) + wcslen(pwszCol) +
|
|
wcslen(m_pTable->GetTableName()) - 4)) + sizeof(WCHAR));
|
|
|
|
// Format SQL Statement
|
|
swprintf(pwszSQL, wszSELECT_COLLISTFROMTBL, pwszCol, m_pTable->GetTableName());
|
|
|
|
SAFE_ALLOC(m_pwszQ1, WCHAR, wcslen(L"<root xmlns:sql=\"urn:schemas-microsoft-com:xml-sql\"><sql:query> for xml auto</sql:query></root>")+wcslen(pwszSQL)+sizeof(WCHAR));
|
|
wcscpy(m_pwszQ1, L"<root xmlns:sql=\"urn:schemas-microsoft-com:xml-sql\"><sql:query>");
|
|
wcscat(m_pwszQ1, pwszSQL);
|
|
wcscat(m_pwszQ1, L" for xml auto</sql:query></root>");
|
|
//m_pwszQ1 = wcsDuplicate(L"<root xmlns:sql=\"urn:schemas-microsoft-com:xml-sql\"><sql:query>select uid from sysusers for xml auto</sql:query></root>");
|
|
SAFE_FREE(pwszSQL);
|
|
|
|
TESTC(m_pwszQ1 != NULL)
|
|
|
|
QUERY2:
|
|
|
|
if(m_pwszQ2)
|
|
goto CLEANUP;
|
|
|
|
m_pwszQ2 = wcsDuplicate(L"<root1>Some valid xml. Will be echoed by Execute.</root1>");
|
|
|
|
TESTC(m_pwszQ2 != NULL)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::GetCmdStream
|
|
//
|
|
HRESULT CCmdStream::GetCmdStream(IID* piid, GUID* pguid, WCHAR** ppwszCmd)
|
|
{
|
|
HRESULT hr=E_FAIL;
|
|
GUID guidIn;
|
|
|
|
if(!m_pICommandStream)
|
|
return E_FAIL;
|
|
|
|
if(pguid)
|
|
guidIn = *pguid;
|
|
|
|
hr = m_pICommandStream->GetCommandStream(piid, pguid, (IUnknown**)&m_pStorageGet);
|
|
if(m_pStorageGet && g_fSQLOLEDB)
|
|
m_pStorageGet->Seek(0);
|
|
|
|
//Common verification
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
COMPARE(m_pStorageGet != NULL, TRUE);
|
|
if(pguid && hr==S_OK)
|
|
COMPARE(*pguid==guidIn, TRUE);
|
|
|
|
if(hr == DB_S_DIALECTIGNORED)
|
|
{
|
|
COMPARE(pguid != NULL, TRUE);
|
|
if(pguid)
|
|
COMPARE(*pguid!=guidIn, TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
COMPARE(m_pStorageGet == NULL, TRUE);
|
|
m_pStorageGet = NULL;
|
|
if(pguid)
|
|
COMPARE(*pguid, GUIDNULL);
|
|
if(piid)
|
|
COMPARE(*piid, IID_NULL);
|
|
}
|
|
|
|
//Mask this code with S_OK for convenience.
|
|
if(hr == DB_S_DIALECTIGNORED)
|
|
{
|
|
odtLog<<L"INFO: GetCommandStream returned DB_S_DIALECTIGNORED.\n";
|
|
hr = S_OK;
|
|
}
|
|
|
|
if(SUCCEEDED(hr) && ppwszCmd)
|
|
{
|
|
hr = Read(ppwszCmd);
|
|
if(m_pStorageGet && g_fSQLOLEDB)
|
|
m_pStorageGet->Seek(0);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::SetCmdStream
|
|
//
|
|
HRESULT CCmdStream::SetCmdStream(IID iid, GUID guid, WCHAR* pwszCmd)
|
|
{
|
|
HRESULT hr=E_FAIL;
|
|
|
|
if(!m_pICommandStream || !m_pStorageSet)
|
|
return E_FAIL;
|
|
|
|
if(pwszCmd)
|
|
{
|
|
CHECK(Write(pwszCmd), S_OK);
|
|
}
|
|
|
|
hr = m_pICommandStream->SetCommandStream(iid, guid, (ISequentialStream*)m_pStorageSet);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::Read
|
|
//
|
|
HRESULT CCmdStream::Read(WCHAR** ppwszCmd, IUnknown* pUnkStream)
|
|
{
|
|
HRESULT hr=E_FAIL;
|
|
ULONG cRead = 0;
|
|
ULONG ulReadIncr = READ_INCR;
|
|
WCHAR* pwszCmd = NULL;
|
|
BYTE* pwszEnd = NULL;
|
|
BOOL fEnd = FALSE;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
if(!pUnkStream)
|
|
pUnkStream = (ISequentialStream*)m_pStorageGet;
|
|
|
|
if(!m_pICommandStream || !pUnkStream || !ppwszCmd)
|
|
return E_FAIL;
|
|
|
|
*ppwszCmd = NULL;
|
|
|
|
TESTC(VerifyInterface(pUnkStream, IID_ISequentialStream,
|
|
STREAM_INTERFACE,(IUnknown **)&pISS))
|
|
|
|
SAFE_ALLOC(pwszCmd, WCHAR, ulReadIncr);
|
|
|
|
//First read 2 bytes only. If this is the byte-order
|
|
//mark, remove it.
|
|
hr = pISS->Read(pwszCmd, 2, &cRead);
|
|
|
|
//If the stream was empty ...
|
|
if((hr==S_FALSE) && (cRead==0))
|
|
{
|
|
fEnd = TRUE;
|
|
SAFE_FREE(pwszCmd);
|
|
}
|
|
|
|
if(cRead==2)
|
|
{
|
|
if(memcmp(wszByteOrder, pwszCmd, 2) == 0)
|
|
{
|
|
hr = pISS->Read(pwszCmd, ulReadIncr, &cRead);
|
|
if(cRead < ulReadIncr)
|
|
{
|
|
fEnd = TRUE;
|
|
pwszEnd = (BYTE*)pwszCmd + cRead;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = pISS->Read((BYTE*)pwszCmd +2, ulReadIncr-2, &cRead);
|
|
if(cRead < ulReadIncr-2)
|
|
{
|
|
fEnd = TRUE;
|
|
pwszEnd = (BYTE*)pwszCmd +2 + cRead;
|
|
}
|
|
}
|
|
}
|
|
|
|
while(!fEnd)
|
|
{
|
|
cRead = 0;
|
|
ulReadIncr += READ_INCR;
|
|
SAFE_REALLOC(pwszCmd, WCHAR, ulReadIncr);
|
|
hr = pISS->Read((BYTE*)pwszCmd +ulReadIncr -READ_INCR, READ_INCR, &cRead);
|
|
if(cRead < READ_INCR)
|
|
{
|
|
fEnd = TRUE;
|
|
pwszEnd = (BYTE*)pwszCmd +ulReadIncr -READ_INCR + cRead;
|
|
}
|
|
}
|
|
|
|
if(pwszEnd)
|
|
memset((BYTE*)pwszEnd, 0, 2);
|
|
|
|
if(fEnd)
|
|
{
|
|
hr = S_OK;
|
|
*ppwszCmd = pwszCmd;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pISS);
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::Write
|
|
//
|
|
HRESULT CCmdStream::Write(WCHAR* pwszCmd)
|
|
{
|
|
HRESULT hr=E_FAIL;
|
|
ULONG cWrote = 0;
|
|
ULONG ulLen = 0;
|
|
|
|
if(!m_pICommandStream || !m_pStorageSet || !pwszCmd)
|
|
return E_FAIL;
|
|
|
|
ulLen = (ULONG)(wcslen(pwszCmd));
|
|
|
|
hr = m_pStorageSet->Write(wszByteOrder, 2, NULL);
|
|
hr = m_pStorageSet->Write(pwszCmd, (ulLen)*sizeof(WCHAR), &cWrote);
|
|
m_pStorageSet->Seek(0);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::PrepCmd
|
|
//
|
|
BOOL CCmdStream::PrepCmd()
|
|
{
|
|
BOOL fRet = FALSE;
|
|
ICommandPrepare* pICmdPrep = NULL;
|
|
|
|
if(VerifyInterface(m_pICommandStream,
|
|
IID_ICommandPrepare, COMMAND_INTERFACE,(IUnknown **)
|
|
&pICmdPrep))
|
|
{
|
|
TESTC_(pICmdPrep->Prepare(1), S_OK)
|
|
}
|
|
|
|
fRet = TRUE;
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pICmdPrep);
|
|
return fRet;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::SetCmdProp
|
|
//
|
|
HRESULT CCmdStream::SetCmdProp(DBPROPSET* rgPropSet, IUnknown* pICmd)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ICommandProperties* pICP = NULL;
|
|
|
|
if(pICmd && !VerifyInterface(pICmd,
|
|
IID_ICommandProperties, COMMAND_INTERFACE,(IUnknown **)
|
|
&pICP))
|
|
return E_FAIL;
|
|
|
|
if(!pICP && !VerifyInterface(m_pICommandStream,
|
|
IID_ICommandProperties, COMMAND_INTERFACE,(IUnknown **)
|
|
&pICP))
|
|
return E_FAIL;
|
|
|
|
if(rgPropSet)
|
|
hr = pICP->SetProperties(1, rgPropSet);
|
|
|
|
SAFE_RELEASE(pICP);
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::SetEncdProp
|
|
//
|
|
HRESULT CCmdStream::SetEncdProp(ENCODING eOE, IUnknown* pICmd)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
BSTR bstr;
|
|
|
|
if(eOE == UTF8)
|
|
bstr = L"UTF-8";
|
|
else if(eOE == UTF16)
|
|
bstr = L"UTF-16";
|
|
else
|
|
return E_FAIL;
|
|
|
|
SetProperty(DBPROP_OUTPUTENCODING, DBPROPSET_STREAM,
|
|
&cPropSets, &rgPropSets, (void*)bstr, DBTYPE_BSTR);
|
|
hr = SetCmdProp(rgPropSets, pICmd);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
if(FAILED(hr))
|
|
DumpPropertyErrors(cPropSets, rgPropSets);
|
|
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::DefTest
|
|
//
|
|
BOOL CCmdStream::DefTest(ICommandStream* pICS)
|
|
{
|
|
TBEGIN
|
|
|
|
TESTC(pICS != NULL)
|
|
TESTC(DefaultObjectTesting(pICS, COMMAND_INTERFACE))
|
|
|
|
CLEANUP:
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::VerifyRowset
|
|
//
|
|
BOOL CCmdStream::VerifyRowset(EQUERY eQuery, IRowset* pIR)
|
|
{
|
|
TBEGIN
|
|
DBCOUNTITEM cRows = 0;
|
|
DBCOUNTITEM ulIndex = 0;
|
|
HROW hRow = 0;
|
|
void* pData = NULL;
|
|
CRowset* pcr = NULL;
|
|
|
|
g_pIDBInitialize = m_pIDBInitialize;
|
|
g_pIOpenRowset = m_pIOpenRowset;
|
|
g_pTable = m_pTable;
|
|
|
|
pcr = new CRowset();
|
|
TESTC(pcr != NULL)
|
|
|
|
//Currently using this only for "select *" query.
|
|
if(eQuery != SELECT_ALLFROMTBL)
|
|
goto CLEANUP;
|
|
|
|
cRows = m_pTable->CountRowsOnTable();
|
|
TESTC(SUCCEEDED(pcr->CreateRowset(pIR, SELECT_ALLFROMTBL)))
|
|
|
|
for(ulIndex=0; ulIndex<cRows; ulIndex++)
|
|
{
|
|
TESTC_(pcr->GetRow(ulIndex+1, &hRow), S_OK)
|
|
TESTC_(pcr->GetRowData(hRow, &pData), S_OK)
|
|
TESTC(pcr->CompareRowData(hRow, pData))
|
|
SAFE_FREE(pData);
|
|
TESTC_(pcr->ReleaseRows(hRow), S_OK)
|
|
}
|
|
|
|
CLEANUP:
|
|
g_pIDBInitialize = NULL;
|
|
g_pIOpenRowset = NULL;
|
|
g_pTable = NULL;
|
|
SAFE_DELETE(pcr);
|
|
SAFE_FREE(pData);
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::VerifyQuery1
|
|
//
|
|
BOOL CCmdStream::VerifyQuery1(IUnknown* pIStream, REFIID riid)
|
|
{
|
|
TBEGIN
|
|
HRESULT hr=E_FAIL;
|
|
CLSID clsid;
|
|
DBTYPE dbType;
|
|
CCol rgCol;
|
|
DOMNodeType nodeType;
|
|
ULONG cRow = 1;
|
|
WCHAR* wszData = NULL;
|
|
WCHAR* pwszVal = NULL;
|
|
WCHAR* pwszColName = NULL;
|
|
IXMLDOMDocument* pXMLDoc = NULL;
|
|
IXMLDOMNode* pNode = NULL;
|
|
IXMLDOMNode* pRoot = NULL;
|
|
IXMLDOMNode* pChild = NULL;
|
|
IXMLDOMNode* pNext = NULL;
|
|
|
|
VARIANT_BOOL bSuccess = VARIANT_FALSE;
|
|
VARIANT streamIn;
|
|
VariantInit(&streamIn);
|
|
|
|
TESTC(pIStream != NULL)
|
|
|
|
V_VT(&streamIn) = VT_UNKNOWN;
|
|
V_UNKNOWN(&streamIn) = (ISequentialStream*)pIStream;
|
|
|
|
pIStream->AddRef();
|
|
|
|
TESTC_(m_pTable->GetColInfo(1, rgCol), S_OK)
|
|
dbType = rgCol.GetProviderType();
|
|
|
|
//TESTC_(hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
|
|
// IID_IXMLDOMDocument, (void**)&pXMLDoc), S_OK)
|
|
|
|
CLSIDFromProgID(L"Msxml2.DOMDocument", &clsid);
|
|
TESTC_(hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IXMLDOMDocument, (void**)&pXMLDoc), S_OK)
|
|
|
|
hr = pXMLDoc->load(streamIn, &bSuccess);
|
|
if(bSuccess != VARIANT_TRUE)
|
|
TESTC_(hr, S_OK)
|
|
|
|
TESTC_(hr = pXMLDoc->QueryInterface(IID_IXMLDOMNode, (void **)&pNode), S_OK)
|
|
|
|
//Find the first node of type NODE_ELEMENT, i.e. the
|
|
//root node.
|
|
TESTC_(hr = pNode->get_nodeType(&nodeType), S_OK)
|
|
if(nodeType == NODE_ELEMENT)
|
|
TESTC(QIDOMNode(pNode, &pRoot))
|
|
else
|
|
{
|
|
//Now recurse into any children...
|
|
TESTC(SUCCEEDED(pNode->get_firstChild(&pChild)))
|
|
while(pChild)
|
|
{
|
|
//Recurse for all siblings...
|
|
TESTC_(hr = pChild->get_nodeType(&nodeType), S_OK)
|
|
if(nodeType == NODE_ELEMENT)
|
|
{
|
|
TESTC(QIDOMNode(pChild, &pRoot))
|
|
break;
|
|
}
|
|
|
|
TESTC(SUCCEEDED(pChild->get_nextSibling(&pNext)))
|
|
TESTC_(hr = pNext->get_nodeType(&nodeType), S_OK)
|
|
if(nodeType == NODE_ELEMENT)
|
|
{
|
|
TESTC(QIDOMNode(pNext, &pRoot))
|
|
break;
|
|
}
|
|
|
|
SAFE_RELEASE(pChild);
|
|
if(pNext)
|
|
TESTC(QIDOMNode(pNext, &pChild))
|
|
SAFE_RELEASE(pNext);
|
|
}
|
|
}
|
|
|
|
SAFE_RELEASE(pNode);
|
|
SAFE_RELEASE(pChild);
|
|
SAFE_RELEASE(pNext);
|
|
|
|
SAFE_ALLOC(wszData, WCHAR, sizeof(WCHAR)*DATA_SIZE);
|
|
|
|
TESTC(SUCCEEDED(pRoot->get_firstChild(&pChild)))
|
|
while(pChild || cRow==1)
|
|
{
|
|
//Recurse for all siblings...
|
|
TESTC_(hr = pChild->get_nodeType(&nodeType), S_OK)
|
|
|
|
if(nodeType == NODE_ELEMENT)
|
|
{
|
|
hr = m_pTable->MakeData(wszData, cRow, 1, PRIMARY, DBTYPE_WSTR);
|
|
GetAttrValue(pChild, &pwszColName, &pwszVal);
|
|
|
|
COMPARE(wcscmp(wszData, pwszVal), 0);
|
|
|
|
cRow++;
|
|
memset(wszData, 0, sizeof(WCHAR)*DATA_SIZE);
|
|
}
|
|
|
|
TESTC(SUCCEEDED(pChild->get_nextSibling(&pNext)))
|
|
|
|
SAFE_RELEASE(pChild);
|
|
if(pNext)
|
|
TESTC(QIDOMNode(pNext, &pChild))
|
|
SAFE_RELEASE(pNext);
|
|
}
|
|
|
|
CLEANUP:
|
|
VariantClear(&streamIn);
|
|
SAFE_FREE(wszData);
|
|
SAFE_FREE(pwszVal);
|
|
SAFE_FREE(pwszColName);
|
|
SAFE_RELEASE(pXMLDoc);
|
|
SAFE_RELEASE(pNode);
|
|
SAFE_RELEASE(pChild);
|
|
SAFE_RELEASE(pNext);
|
|
SAFE_RELEASE(pRoot);
|
|
TRETURN;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::QIDOMNode
|
|
//
|
|
BOOL CCmdStream::QIDOMNode(IXMLDOMNode* pIn, IXMLDOMNode** ppOut)
|
|
{
|
|
TBEGIN
|
|
|
|
TESTC(pIn && ppOut)
|
|
|
|
TESTC_(pIn->QueryInterface(IID_IXMLDOMNode, (void **)ppOut), S_OK)
|
|
|
|
CLEANUP:
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::GetAttrValue
|
|
//
|
|
BOOL CCmdStream::GetAttrValue(IXMLDOMNode* pNode, WCHAR** ppwszName, WCHAR** ppwszVal)
|
|
{
|
|
TBEGIN
|
|
VARIANT var;
|
|
BSTR bstrName = NULL;
|
|
IXMLDOMNamedNodeMap* pAttrs = NULL;
|
|
IXMLDOMNode* pChild = NULL;;
|
|
|
|
VariantInit(&var);
|
|
|
|
TESTC(pNode && ppwszName && ppwszVal)
|
|
|
|
TESTC(SUCCEEDED(pNode->get_attributes(&pAttrs)))
|
|
|
|
TESTC(SUCCEEDED(pAttrs->nextNode(&pChild)))
|
|
|
|
//Attribute name
|
|
TESTC(SUCCEEDED(pChild->get_nodeName(&bstrName)))
|
|
*ppwszName = wcsDuplicate(bstrName);
|
|
|
|
//Attribute Value
|
|
TESTC(SUCCEEDED(pChild->get_nodeValue(&var)))
|
|
VariantChangeType(&var, &var, 0, DBTYPE_BSTR);
|
|
|
|
*ppwszVal = wcsDuplicate(V_BSTR(&var));
|
|
|
|
CLEANUP:
|
|
VariantClear(&var);
|
|
SYSSTRING_FREE(bstrName);
|
|
SAFE_RELEASE(pAttrs);
|
|
SAFE_RELEASE(pChild);
|
|
TRETURN
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// CCmdStream::VerifyQuery2
|
|
//
|
|
BOOL CCmdStream::VerifyQuery2(IUnknown* pIStream, REFIID riid)
|
|
{
|
|
TBEGIN
|
|
HRESULT hr=E_FAIL;
|
|
WCHAR* pwszCmd = NULL;
|
|
|
|
TESTC(pIStream != NULL)
|
|
|
|
TESTC_(Read(&pwszCmd, pIStream), S_OK)
|
|
|
|
TESTC(wcsstr(pwszCmd, m_pwszQ2) != NULL)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszCmd);
|
|
TRETURN;
|
|
}
|
|
|
|
|
|
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// Test Case Section
|
|
//*-----------------------------------------------------------------------
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCGetCmdStream)
|
|
//*-----------------------------------------------------------------------
|
|
// @class Test Case for GetCommandStream method
|
|
//
|
|
class TCGetCmdStream : public CCmdStream {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCGetCmdStream,CCmdStream);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// {{ TCW_TESTVARS()
|
|
// @cmember Verify the command object
|
|
int Variation_1();
|
|
// @cmember DB_E_NOCOMMAND: Get on a fresh cmd object
|
|
int Variation_2();
|
|
// @cmember S_OK: Set/Get ISequentialStream (unprep cmd)
|
|
int Variation_3();
|
|
// @cmember S_OK: Set/Get IStream (unprep cmd)
|
|
int Variation_4();
|
|
// @cmember S_OK: Set/Get ILockBytes (unprep cmd)
|
|
int Variation_5();
|
|
// @cmember S_OK: Set/Get ISequentialStream (prep cmd)
|
|
int Variation_6();
|
|
// @cmember S_OK: Set/Get IStream (prep cmd)
|
|
int Variation_7();
|
|
// @cmember S_OK: Set/Get ILockBytes (prep cmd)
|
|
int Variation_8();
|
|
// @cmember S_OK: Set/Get ISequentialStream (cmd props, optional)
|
|
int Variation_9();
|
|
// @cmember S_OK: Set/Get ISequentialStream (cmd props, required)
|
|
int Variation_10();
|
|
// @cmember S_OK: Set/Get IStream (cmd props)
|
|
int Variation_11();
|
|
// @cmember S_OK: Set/Get ILockBytes (cmd props)
|
|
int Variation_12();
|
|
// @cmember S_OK: Set, Execute (result open), Get
|
|
int Variation_13();
|
|
// @cmember S_OK: Set, Execute (result release), Get
|
|
int Variation_14();
|
|
// @cmember S_OK: Set/Get. Verify cmd stream object lifetime
|
|
int Variation_15();
|
|
// @cmember S_OK: Overwrite command in stream got from GetCmdStream.
|
|
int Variation_16();
|
|
// @cmember S_OK: SetCmdStream. Change underlying cmd. Execute.
|
|
int Variation_17();
|
|
// @cmember S_OK: Set/Get unaffected by Abort transaction.
|
|
int Variation_18();
|
|
// @cmember S_OK: CreateCommand with IID_ICommandStream.
|
|
int Variation_19();
|
|
// @cmember S_OK: GetSpecification with IID_ICommandStream.
|
|
int Variation_20();
|
|
// @cmember S_OK: Test stream got from GetCmdStream (seek, clone, read 1 byte at a time)
|
|
int Variation_21();
|
|
// @cmember S_OK: GetCmdStream. Read partially. GetCmdStream. Read whole.
|
|
int Variation_22();
|
|
// @cmember S_OK: Get ICommandStream on a ROW object's cmd obj.
|
|
int Variation_23();
|
|
// @cmember S_OK: pGuidDialect is NULL
|
|
int Variation_24();
|
|
// @cmember S_OK: piid is NULL
|
|
int Variation_25();
|
|
// @cmember S_OK: piid & pGuidDialect are NULL
|
|
int Variation_26();
|
|
// @cmember S_OK: Set/Get an empty stream
|
|
int Variation_27();
|
|
// @cmember S_OK: Set/Get a very large stream
|
|
int Variation_28();
|
|
// @cmember S_OK: test limitation of using ISequentialStream
|
|
int Variation_29();
|
|
// @cmember S_OK: SetCmdStream, SetCmdStream, GetCmdStream
|
|
int Variation_30();
|
|
// @cmember S_OK: SetCmdStream, SetCmdStream (different cmd), GetCmdStream
|
|
int Variation_31();
|
|
// @cmember S_OK: SetCmdStream, SetCmdStream (different IID), GetCmdStream
|
|
int Variation_32();
|
|
// @cmember S_OK: SetCmdStream, GetCmdStream, GetCmdStream
|
|
int Variation_33();
|
|
// @cmember S_OK: SetCmdText, SetCmdStream, GetCmdText, GetCmdStream
|
|
int Variation_34();
|
|
// @cmember S_OK: SetCmdStream, SetCmdText, GetCmdStream, GetCmdText
|
|
int Variation_35();
|
|
// @cmember S_OK: SetCmdStream, SetCmdText (make call fail), GetCmdStream succeeds.
|
|
int Variation_36();
|
|
// @cmember S_OK: SetCmdText, SetCmdStream (make call fail), GetCmdText succeeds.
|
|
int Variation_37();
|
|
// @cmember DB_S_DIALECTIGNORED: Set and Get with different GUIDS
|
|
int Variation_38();
|
|
// @cmember E_INVALIDARG: ppCommandStream is NULL
|
|
int Variation_39();
|
|
// @cmember DB_E_NOCOMMAND: SetCmdStream, SetCmdStream(NULL), GetCmdStream
|
|
int Variation_40();
|
|
// @cmember DB_E_NOCOMMAND: SetCmdStream, SetCmdText (NULL), GetCmdStream
|
|
int Variation_41();
|
|
// @cmember DB_E_CANTTRANSLATE: SetCmdText, GetCmdStream
|
|
int Variation_42();
|
|
// }} TCW_TESTVARS_END
|
|
} ;
|
|
// {{ TCW_TESTCASE(TCGetCmdStream)
|
|
#define THE_CLASS TCGetCmdStream
|
|
BEG_TEST_CASE(TCGetCmdStream, CCmdStream, L"Test Case for GetCommandStream method")
|
|
TEST_VARIATION(1, L"Verify the command object")
|
|
TEST_VARIATION(2, L"DB_E_NOCOMMAND: Get on a fresh cmd object")
|
|
TEST_VARIATION(3, L"S_OK: Set/Get ISequentialStream (unprep cmd)")
|
|
TEST_VARIATION(4, L"S_OK: Set/Get IStream (unprep cmd)")
|
|
TEST_VARIATION(5, L"S_OK: Set/Get ILockBytes (unprep cmd)")
|
|
TEST_VARIATION(6, L"S_OK: Set/Get ISequentialStream (prep cmd)")
|
|
TEST_VARIATION(7, L"S_OK: Set/Get IStream (prep cmd)")
|
|
TEST_VARIATION(8, L"S_OK: Set/Get ILockBytes (prep cmd)")
|
|
TEST_VARIATION(9, L"S_OK: Set/Get ISequentialStream (cmd props, optional)")
|
|
TEST_VARIATION(10, L"S_OK: Set/Get ISequentialStream (cmd props, required)")
|
|
TEST_VARIATION(11, L"S_OK: Set/Get IStream (cmd props)")
|
|
TEST_VARIATION(12, L"S_OK: Set/Get ILockBytes (cmd props)")
|
|
TEST_VARIATION(13, L"S_OK: Set, Execute (result open), Get")
|
|
TEST_VARIATION(14, L"S_OK: Set, Execute (result release), Get")
|
|
TEST_VARIATION(15, L"S_OK: Set/Get. Verify cmd stream object lifetime")
|
|
TEST_VARIATION(16, L"S_OK: Overwrite command in stream got from GetCmdStream.")
|
|
TEST_VARIATION(17, L"S_OK: SetCmdStream. Change underlying cmd. Execute.")
|
|
TEST_VARIATION(18, L"S_OK: Set/Get unaffected by Abort transaction.")
|
|
TEST_VARIATION(19, L"S_OK: CreateCommand with IID_ICommandStream.")
|
|
TEST_VARIATION(20, L"S_OK: GetSpecification with IID_ICommandStream.")
|
|
TEST_VARIATION(21, L"S_OK: Test stream got from GetCmdStream (seek, clone, read 1 byte at a time)")
|
|
TEST_VARIATION(22, L"S_OK: GetCmdStream. Read partially. GetCmdStream. Read whole.")
|
|
TEST_VARIATION(23, L"S_OK: Get ICommandStream on a ROW object's cmd obj.")
|
|
TEST_VARIATION(24, L"S_OK: pGuidDialect is NULL")
|
|
TEST_VARIATION(25, L"S_OK: piid is NULL")
|
|
TEST_VARIATION(26, L"S_OK: piid & pGuidDialect are NULL")
|
|
TEST_VARIATION(27, L"S_OK: Set/Get an empty stream")
|
|
TEST_VARIATION(28, L"S_OK: Set/Get a very large stream")
|
|
TEST_VARIATION(29, L"S_OK: test limitation of using ISequentialStream")
|
|
TEST_VARIATION(30, L"S_OK: SetCmdStream, SetCmdStream, GetCmdStream")
|
|
TEST_VARIATION(31, L"S_OK: SetCmdStream, SetCmdStream (different cmd), GetCmdStream")
|
|
TEST_VARIATION(32, L"S_OK: SetCmdStream, SetCmdStream (different IID), GetCmdStream")
|
|
TEST_VARIATION(33, L"S_OK: SetCmdStream, GetCmdStream, GetCmdStream")
|
|
TEST_VARIATION(34, L"S_OK: SetCmdText, SetCmdStream, GetCmdText, GetCmdStream")
|
|
TEST_VARIATION(35, L"S_OK: SetCmdStream, SetCmdText, GetCmdStream, GetCmdText")
|
|
TEST_VARIATION(36, L"S_OK: SetCmdStream, SetCmdText (make call fail), GetCmdStream succeeds.")
|
|
TEST_VARIATION(37, L"S_OK: SetCmdText, SetCmdStream (make call fail), GetCmdText succeeds.")
|
|
TEST_VARIATION(38, L"DB_S_DIALECTIGNORED: Set and Get with different GUIDS")
|
|
TEST_VARIATION(39, L"E_INVALIDARG: ppCommandStream is NULL")
|
|
TEST_VARIATION(40, L"DB_E_NOCOMMAND: SetCmdStream, SetCmdStream(NULL), GetCmdStream")
|
|
TEST_VARIATION(41, L"DB_E_NOCOMMAND: SetCmdStream, SetCmdText (NULL), GetCmdStream")
|
|
TEST_VARIATION(42, L"DB_E_CANTTRANSLATE: SetCmdText, GetCmdStream")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCSetCmdStream)
|
|
//*-----------------------------------------------------------------------
|
|
// @class SetCommandStream Test Case
|
|
//
|
|
class TCSetCmdStream : public CCmdStream {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCSetCmdStream,CCmdStream);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// {{ TCW_TESTVARS()
|
|
// @cmember S_OK: Set cmd props. SetCmdStream. Execute.
|
|
int Variation_1();
|
|
// @cmember S_OK: Execute CmdText, release rowset, SetCmdStream
|
|
int Variation_2();
|
|
// @cmember S_OK: Set/Get/Execute. Verify cmd stream object lifetime
|
|
int Variation_3();
|
|
// @cmember S_OK: Execute some privlib queries and verify.
|
|
int Variation_4();
|
|
// @cmember S_OK: pCommandStream is NULL (cmd state reset)
|
|
int Variation_5();
|
|
// @cmember S_OK: SetCmdStream with stream containing 2 cmds. Ptr on 2nd.
|
|
int Variation_6();
|
|
// @cmember S_OK: SetCmdStream & Execute diffr queries on diffr cmd objs.
|
|
int Variation_7();
|
|
// @cmember S_OK: SetCmdStream, Prepare, GetColInfo.
|
|
int Variation_8();
|
|
// @cmember S_OK: SetCmdStream, Prepare, GetColumnsRowset.
|
|
int Variation_9();
|
|
// @cmember S_OK: Implement stream on a large file. SetCmdStream.
|
|
int Variation_10();
|
|
// @cmember S_OK: Aggregate stream got from Execute.
|
|
int Variation_11();
|
|
// @cmember DB_E_ERRORSINCOMMAND: SetCmdStream with an embedded NULL terminator.
|
|
int Variation_12();
|
|
// @cmember DB_E_ERRORSINCOMMAND: Set unicode stream without BOM
|
|
int Variation_13();
|
|
// @cmember S_OK: Set stream as ansi - no BOM
|
|
int Variation_14();
|
|
// @cmember S_OK: Set DBPROP_DEFERRED.
|
|
int Variation_15();
|
|
// @cmember S_OK: Call SetCmdStream so it fails. Ref cnt unchanged.
|
|
int Variation_16();
|
|
// @cmember S_OK: Release all objects & verify no ref cnts left on stream.
|
|
int Variation_17();
|
|
// @cmember S_OK: SetCmdStream, GetCmdStream, SetCmdStream with stream got. Execute.
|
|
int Variation_18();
|
|
// @cmember S_OK: SetCmdStream, Execute, GetCmdStream
|
|
int Variation_19();
|
|
// @cmember S_OK: SetCmdStream, GetCmdStream, Execute
|
|
int Variation_20();
|
|
// @cmember S_OK: SetCmdStream, Execute, Execute
|
|
int Variation_21();
|
|
// @cmember S_OK: SetCmdText, SetCmdStream, Execute
|
|
int Variation_22();
|
|
// @cmember S_OK: SetCmdStream, GetCmdStream, SetCmdText, Execute. Read got stream.
|
|
int Variation_23();
|
|
// @cmember S_OK: Ask for IUnknown on Execute.
|
|
int Variation_24();
|
|
// @cmember DBPROP_OUTPUTSTREAM - ISequentialStream
|
|
int Variation_25();
|
|
// @cmember DBPROP_OUTPUTSTREAM - ISequentialStream (NULL ppRowset)
|
|
int Variation_26();
|
|
// @cmember DBPROP_OUTPUTSTREAM - IStream
|
|
int Variation_27();
|
|
// @cmember DBPROP_OUTPUTENCODING - UTF-8
|
|
int Variation_28();
|
|
// @cmember DBPROP_OUTPUTENCODING - UTF-16
|
|
int Variation_29();
|
|
// @cmember E_NOINTERFACE: iid passed in does not match object
|
|
int Variation_30();
|
|
// @cmember E_NOINTERFACE: iid is IRowset & IRow.
|
|
int Variation_31();
|
|
// @cmember DB_E_CANTTRANSLATE: SetCmdStream, GetCmdText
|
|
int Variation_32();
|
|
// @cmember DB_E_DIALECTNOTSUPPORTED: Use some bugs guids & DBGUID_NULL
|
|
int Variation_33();
|
|
// @cmember DB_E_DIALECTNOTSUPPORTED (or S_OK): use DBGUID_SQL.
|
|
int Variation_34();
|
|
// @cmember DB_E_OBJECTOPEN: Keeping a result stream open, call Set.
|
|
int Variation_35();
|
|
// @cmember Clear previous error object.
|
|
int Variation_36();
|
|
// @cmember Extended error test - GetCmdStream
|
|
int Variation_37();
|
|
// @cmember Extended error test - SetCmdStream
|
|
int Variation_38();
|
|
// }} TCW_TESTVARS_END
|
|
} ;
|
|
// {{ TCW_TESTCASE(TCSetCmdStream)
|
|
#define THE_CLASS TCSetCmdStream
|
|
BEG_TEST_CASE(TCSetCmdStream, CCmdStream, L"SetCommandStream Test Case")
|
|
TEST_VARIATION(1, L"S_OK: Set cmd props. SetCmdStream. Execute.")
|
|
TEST_VARIATION(2, L"S_OK: Execute CmdText, release rowset, SetCmdStream")
|
|
TEST_VARIATION(3, L"S_OK: Set/Get/Execute. Verify cmd stream object lifetime")
|
|
TEST_VARIATION(4, L"S_OK: Execute some privlib queries and verify.")
|
|
TEST_VARIATION(5, L"S_OK: pCommandStream is NULL (cmd state reset)")
|
|
TEST_VARIATION(6, L"S_OK: SetCmdStream with stream containing 2 cmds. Ptr on 2nd.")
|
|
TEST_VARIATION(7, L"S_OK: SetCmdStream & Execute diffr queries on diffr cmd objs.")
|
|
TEST_VARIATION(8, L"S_OK: SetCmdStream, Prepare, GetColInfo.")
|
|
TEST_VARIATION(9, L"S_OK: SetCmdStream, Prepare, GetColumnsRowset.")
|
|
TEST_VARIATION(10, L"S_OK: Implement stream on a large file. SetCmdStream.")
|
|
TEST_VARIATION(11, L"S_OK: Aggregate stream got from Execute.")
|
|
TEST_VARIATION(12, L"DB_E_ERRORSINCOMMAND: SetCmdStream with an embedded NULL terminator.")
|
|
TEST_VARIATION(13, L"DB_E_ERRORSINCOMMAND: Set unicode stream without BOM")
|
|
TEST_VARIATION(14, L"S_OK: Set stream as ansi - no BOM")
|
|
TEST_VARIATION(15, L"S_OK: Set DBPROP_DEFERRED.")
|
|
TEST_VARIATION(16, L"S_OK: Call SetCmdStream so it fails. Ref cnt unchanged.")
|
|
TEST_VARIATION(17, L"S_OK: Release all objects & verify no ref cnts left on stream.")
|
|
TEST_VARIATION(18, L"S_OK: SetCmdStream, GetCmdStream, SetCmdStream with stream got. Execute.")
|
|
TEST_VARIATION(19, L"S_OK: SetCmdStream, Execute, GetCmdStream")
|
|
TEST_VARIATION(20, L"S_OK: SetCmdStream, GetCmdStream, Execute")
|
|
TEST_VARIATION(21, L"S_OK: SetCmdStream, Execute, Execute")
|
|
TEST_VARIATION(22, L"S_OK: SetCmdText, SetCmdStream, Execute")
|
|
TEST_VARIATION(23, L"S_OK: SetCmdStream, GetCmdStream, SetCmdText, Execute. Read got stream.")
|
|
TEST_VARIATION(24, L"S_OK: Ask for IUnknown on Execute.")
|
|
TEST_VARIATION(25, L"DBPROP_OUTPUTSTREAM - ISequentialStream")
|
|
TEST_VARIATION(26, L"DBPROP_OUTPUTSTREAM - ISequentialStream (NULL ppRowset)")
|
|
TEST_VARIATION(27, L"DBPROP_OUTPUTSTREAM - IStream")
|
|
TEST_VARIATION(28, L"DBPROP_OUTPUTENCODING - UTF-8")
|
|
TEST_VARIATION(29, L"DBPROP_OUTPUTENCODING - UTF-16")
|
|
TEST_VARIATION(30, L"E_NOINTERFACE: iid passed in does not match object")
|
|
TEST_VARIATION(31, L"E_NOINTERFACE: iid is IRowset & IRow.")
|
|
TEST_VARIATION(32, L"DB_E_CANTTRANSLATE: SetCmdStream, GetCmdText")
|
|
TEST_VARIATION(33, L"DB_E_DIALECTNOTSUPPORTED: Use some bugs guids & DBGUID_NULL")
|
|
TEST_VARIATION(34, L"DB_E_DIALECTNOTSUPPORTED (or S_OK): use DBGUID_SQL.")
|
|
TEST_VARIATION(35, L"DB_E_OBJECTOPEN: Keeping a result stream open, call Set.")
|
|
TEST_VARIATION(36, L"Clear previous error object.")
|
|
TEST_VARIATION(37, L"Extended error test - GetCmdStream")
|
|
TEST_VARIATION(38, L"Extended error test - SetCmdStream")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
|
|
// }} END_DECLARE_TEST_CASES()
|
|
|
|
|
|
|
|
// {{ TCW_TESTMODULE(ThisModule)
|
|
TEST_MODULE(2, ThisModule, gwszModuleDescrip)
|
|
TEST_CASE(1, TCGetCmdStream)
|
|
TEST_CASE(2, TCSetCmdStream)
|
|
END_TEST_MODULE()
|
|
// }} TCW_TESTMODULE_END
|
|
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCGetCmdStream)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCGetCmdStream - Test Case for GetCommandStream method
|
|
//| Created: 10/26/1999
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCGetCmdStream::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(CCmdStream::Init())
|
|
// }}
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Verify the command object
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_1()
|
|
{
|
|
TBEGIN
|
|
|
|
TESTC(DefaultObjectTesting(m_pICommandStream, COMMAND_INTERFACE))
|
|
|
|
CLEANUP:
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_NOCOMMAND: Get on a fresh cmd object
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_2()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid = IID_IAccessor;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid), DB_E_NOCOMMAND)
|
|
|
|
CLEANUP:
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ISequentialStream (unprep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_3()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL), S_OK, E_OUTOFMEMORY)
|
|
if(hr != S_OK)
|
|
{
|
|
odtLog<<L"INFO: Could not create SQL stmt for "<<GetSQLTokenName((EQUERY)rgSQLTokens[i].lItem)<<".\n";
|
|
continue;
|
|
}
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(4)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get IStream (unprep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_4()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL), S_OK, E_OUTOFMEMORY)
|
|
if(hr != S_OK)
|
|
{
|
|
odtLog<<L"INFO: Could not create SQL stmt for "<<GetSQLTokenName((EQUERY)rgSQLTokens[i].lItem)<<".\n";
|
|
continue;
|
|
}
|
|
|
|
//IID_IStream may not be supported.
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_IStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(5)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ILockBytes (unprep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_5()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL), S_OK, E_OUTOFMEMORY)
|
|
if(hr != S_OK)
|
|
{
|
|
odtLog<<L"INFO: Could not create SQL stmt for "<<GetSQLTokenName((EQUERY)rgSQLTokens[i].lItem)<<".\n";
|
|
continue;
|
|
}
|
|
|
|
//IID_IStream may not be supported.
|
|
TEST2C_(hr = SetCmdStream(IID_ILockBytes, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ILockBytes);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(6)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ISequentialStream (prep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_6()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//Prepare the command.
|
|
TESTC(PrepCmd())
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(7)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get IStream (prep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_7()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
//IID_IStream may not be supported.
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
//Prepare the command.
|
|
TESTC(PrepCmd())
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_IStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(8)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ILockBytes (prep cmd)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_8()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(ULONG i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
//IID_IStream may not be supported.
|
|
TEST2C_(hr = SetCmdStream(IID_ILockBytes, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
//Prepare the command.
|
|
TESTC(PrepCmd())
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ILockBytes);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(9)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ISequentialStream (cmd props, optional)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_9()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
SetProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET, &cPropSets, &rgPropSets, (void*)VARIANT_TRUE, DBTYPE_BOOL, DBPROPOPTIONS_OPTIONAL);
|
|
SetProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET, &cPropSets, &rgPropSets, (void*)VARIANT_TRUE, DBTYPE_BOOL, DBPROPOPTIONS_OPTIONAL);
|
|
SetProperty(DBPROP_UPDATABILITY, DBPROPSET_ROWSET, &cPropSets, &rgPropSets, (void*)(DBPROPVAL_UP_CHANGE|DBPROPVAL_UP_DELETE|DBPROPVAL_UP_INSERT), DBTYPE_I4, DBPROPOPTIONS_OPTIONAL);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_S_ERRORSOCCURRED, TRUE);
|
|
|
|
ULONG i;
|
|
//Loop through all the possible Queries...
|
|
for(i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
//unset the 3 properties which were set above.
|
|
for(i=0; i<3; i++)
|
|
VariantClear(&rgPropSets[0].rgProperties[i].vValue);
|
|
SetCmdProp(rgPropSets);
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(10)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ISequentialStream (cmd props, required)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_10()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
SetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
SetProperty(DBPROP_CANFETCHBACKWARDS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
SetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
|
|
ULONG i;
|
|
//Loop through all the possible Queries...
|
|
for(i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
//unset the 3 properties which were set above.
|
|
for(i=0; i<3; i++)
|
|
VariantClear(&rgPropSets[0].rgProperties[i].vValue);
|
|
SetCmdProp(rgPropSets);
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(11)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get IStream (cmd props)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_11()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
SetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
SetProperty(DBPROP_CANFETCHBACKWARDS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets, (void*)VARIANT_TRUE, DBTYPE_BOOL, DBPROPOPTIONS_OPTIONAL);
|
|
SetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_S_ERRORSOCCURRED || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
|
|
ULONG i;
|
|
//Loop through all the possible Queries...
|
|
for(i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_IStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
//unset the 3 properties which were set above.
|
|
for(i=0; i<3; i++)
|
|
VariantClear(&rgPropSets[0].rgProperties[i].vValue);
|
|
SetCmdProp(rgPropSets);
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(12)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get ILockBytes (cmd props)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_12()
|
|
{
|
|
TBEGIN
|
|
ULONG i=0;
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
NAMEMAP* rgSQLTokens = NULL;
|
|
ULONG cSQLTokens = GetSQLTokenMap(&rgSQLTokens);
|
|
|
|
SetProperty(DBPROP_IRowsetIdentity, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
SetProperty(DBPROP_IRowsetFind, DBPROPSET_ROWSET, &cPropSets, &rgPropSets, (void*)VARIANT_TRUE, DBTYPE_BOOL, DBPROPOPTIONS_OPTIONAL);
|
|
SetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_S_ERRORSOCCURRED || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
|
|
//Loop through all the possible Queries...
|
|
for(i=0; i<cSQLTokens; i++)
|
|
{
|
|
ALLOC_SETSTG;
|
|
|
|
if(m_pTable->CreateSQLStmt((EQUERY)rgSQLTokens[i].lItem, m_pTable->GetTableName(), &pwszSQL) != S_OK)
|
|
continue;
|
|
|
|
TEST2C_(hr = SetCmdStream(IID_ILockBytes, DBGUID_DEFAULT, pwszSQL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ILockBytes);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
}
|
|
|
|
CLEANUP:
|
|
//unset the 3 properties which were set above.
|
|
for(i=0; i<3; i++)
|
|
VariantClear(&rgPropSets[0].rgProperties[i].vValue);
|
|
SetCmdProp(rgPropSets);
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(13)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set, Execute (result open), Get
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_13()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
WCHAR* pwszCmd = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
TESTC(pwszSQLGet!=NULL)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(14)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set, Execute (result release), Get
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_14()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
SAFE_RELEASE(pISS);
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
TESTC(pwszSQLGet!=NULL)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(15)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get. Verify cmd stream object lifetime
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_15()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
ULONG cRef1=0, cRef2=0, cRef3=0;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
cRef1 = m_pStorageSet->GetRefCount();
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
cRef2 = m_pStorageSet->GetRefCount();
|
|
COMPARE(cRef2 > cRef1, TRUE);
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
cRef3 = m_pStorageSet->GetRefCount();
|
|
COMPARE(cRef3 > cRef2, TRUE);
|
|
|
|
COMPARE(pwszSQL && pwszSQLGet, TRUE);
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
m_pStorageGet->Release();
|
|
COMPARE(cRef2, m_pStorageGet->GetRefCount());
|
|
m_pStorageGet = NULL;
|
|
|
|
m_pStorageSet->Release();
|
|
COMPARE(cRef1, m_pStorageSet->GetRefCount());
|
|
m_pStorageSet = NULL;
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(16)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Overwrite command in stream got from GetCmdStream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_16()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
WCHAR* pwszStream = NULL;
|
|
ULONG cWrote = 0;
|
|
ULONG ulLen = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), S_OK)
|
|
|
|
//Overwrite command in the m_pStorageGet stream.
|
|
ulLen = (ULONG)wcslen(m_pwszQ2);
|
|
TESTC_(hr = m_pStorageGet->Write(wszByteOrder, 2, NULL), S_OK);
|
|
TESTC_(hr = m_pStorageGet->Write(m_pwszQ2, (ulLen)*sizeof(WCHAR), &cWrote), S_OK);
|
|
m_pStorageGet->Seek(0);
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_FREE(pwszStream);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(17)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream. Change underlying cmd. Execute.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_17()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
//Overwrite the stream that was set with another cmd.
|
|
TESTC_(Write(m_pwszQ2), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(18)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get unaffected by Abort transaction.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_18()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG ulTLevel = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ITransactionLocal* pITL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_PROVIDER(VerifyInterface(m_pIOpenRowset,
|
|
IID_ITransactionLocal, SESSION_INTERFACE,(IUnknown **)&pITL))
|
|
|
|
TESTC_(pITL->StartTransaction(ISOLATIONLEVEL_READUNCOMMITTED,0,NULL,&ulTLevel), S_OK)
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(pITL->Abort(NULL, FALSE,NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pITL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(19)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: CreateCommand with IID_ICommandStream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_19()
|
|
{
|
|
TBEGIN
|
|
IDBCreateCommand* pIDBCC = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
ICommandText* pICT = NULL;
|
|
|
|
TESTC(VerifyInterface(m_pIOpenRowset,
|
|
IID_IDBCreateCommand, SESSION_INTERFACE,(IUnknown **)&pIDBCC))
|
|
|
|
TESTC_(pIDBCC->CreateCommand(NULL, IID_ICommandStream, (IUnknown**)&pICS), S_OK)
|
|
TESTC(DefTest(pICS))
|
|
|
|
TESTC(VerifyInterface(pICS, IID_ICommandText,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICT))
|
|
TESTC(DefaultInterfaceTesting(pICT, COMMAND_INTERFACE, IID_ICommandText))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
SAFE_RELEASE(pICT);
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(20)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: GetSpecification with IID_ICommandStream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_20()
|
|
{
|
|
TBEGIN
|
|
IRowsetInfo* pIRI = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
|
|
TESTC_(m_pTable->ExecuteCommand(SELECT_ALLFROMTBL,
|
|
IID_IRowsetInfo, NULL, NULL, NULL, NULL,
|
|
EXECUTE_IFNOERROR, 0, NULL, NULL, (IUnknown**)&pIRI,
|
|
(ICommand**)&m_pICommandText), S_OK)
|
|
TESTC(pIRI != NULL)
|
|
|
|
TESTC_(pIRI->GetSpecification(IID_ICommandStream, (IUnknown**)&pICS), S_OK)
|
|
TESTC(DefTest(pICS))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pIRI);
|
|
SAFE_RELEASE(pICS);
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(21)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Test stream got from GetCmdStream (seek, clone, read 1 byte at a time)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_21()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ULONG cRead = 0;
|
|
ULONG ulReadIncr = 1;
|
|
BYTE* pwszEnd = NULL;
|
|
BOOL fEnd = FALSE;
|
|
IStream* pClone = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_PROVIDER(SetCmdStream(IID_IStream, DBGUID_DEFAULT, pwszSQL) == S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), S_OK)
|
|
COMPARE(iid, IID_IStream);
|
|
|
|
SAFE_ALLOC(pwszSQLGet, WCHAR, READ_INCR);
|
|
|
|
//-----------------------------------------------------
|
|
//Read 1 byte at a time.
|
|
//-----------------------------------------------------
|
|
|
|
hr = m_pStorageGet->Read(pwszSQLGet, 2, &cRead);
|
|
if(cRead==2)
|
|
{
|
|
if(memcmp(wszByteOrder, pwszSQLGet, 2) == 0)
|
|
{
|
|
hr = m_pStorageGet->Read(pwszSQLGet, 1, &cRead);
|
|
hr = m_pStorageGet->Read((BYTE*)pwszSQLGet+1, 1, &cRead);
|
|
}
|
|
}
|
|
|
|
//Read only 1 byte at a time.
|
|
while(!fEnd)
|
|
{
|
|
cRead = 0;
|
|
ulReadIncr += 1;
|
|
if((ulReadIncr/2 > READ_INCR) && !(ulReadIncr%2))
|
|
SAFE_REALLOC(pwszSQLGet, WCHAR, READ_INCR+ulReadIncr/2);
|
|
hr = m_pStorageGet->Read((BYTE*)pwszSQLGet+ulReadIncr, 1, &cRead);
|
|
if(cRead < 1)
|
|
{
|
|
fEnd = TRUE;
|
|
pwszEnd = (BYTE*)pwszSQLGet +ulReadIncr;
|
|
}
|
|
}
|
|
|
|
memset((BYTE*)pwszEnd, 0, 2);
|
|
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
SAFE_FREE(pwszSQLGet);
|
|
ulReadIncr = 1;
|
|
cRead = 0;
|
|
|
|
//-----------------------------------------------------
|
|
// CLONE stream. Read cloned stream.
|
|
//-----------------------------------------------------
|
|
|
|
TEST2C_(hr = m_pStorageGet->Clone(&pClone), S_OK, E_NOTIMPL)
|
|
|
|
if(hr != S_OK)
|
|
{
|
|
odtLog<<L"WARNING: Got back an IStream which does not implement the method CLONE.\n";
|
|
goto SEEK;
|
|
}
|
|
|
|
TESTC(pClone != NULL)
|
|
|
|
TESTC_(Read(&pwszSQLGet, pClone), S_OK)
|
|
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
SAFE_FREE(pwszSQLGet);
|
|
ulReadIncr = 1;
|
|
cRead = 0;
|
|
|
|
//-----------------------------------------------------
|
|
// SEEK original stream.
|
|
//-----------------------------------------------------
|
|
SEEK:
|
|
|
|
TESTC_(m_pStorageGet->Seek(0), S_OK)
|
|
|
|
TESTC_(Read(&pwszSQLGet, (ISequentialStream*)m_pStorageGet), S_OK)
|
|
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pClone);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(22)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: GetCmdStream. Read partially. GetCmdStream. Read whole.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_22()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
WCHAR* pwszSQLGet2 = NULL;
|
|
ULONG cRead = 0;
|
|
ULONG ulReadIncr = 1;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), S_OK)
|
|
|
|
SAFE_ALLOC(pwszSQLGet, WCHAR, 3000);
|
|
|
|
//Read first stream partially.
|
|
hr = m_pStorageGet->Read(pwszSQLGet, 4, &cRead);
|
|
|
|
//Get another stream and read it fully.
|
|
TEST2C_(hr = m_pICommandStream->GetCommandStream(&iid, &guid, (IUnknown**)&pISS), S_OK, DB_S_DIALECTIGNORED)
|
|
|
|
TESTC_(Read(&pwszSQLGet, pISS), S_OK)
|
|
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_FREE(pwszSQLGet2);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(23)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Get ICommandStream on a ROW object's cmd obj.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_23()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cProps = 0;
|
|
DBPROPSET* rgProps = NULL;
|
|
IDBCreateCommand* pIDBCC = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
|
|
SetProperty(DBPROP_IRow, DBPROPSET_ROWSET, &cProps, &rgProps);
|
|
|
|
TEST3C_(hr = m_pIOpenRowset->OpenRowset(NULL,
|
|
&(m_pTable->GetTableID()), NULL, IID_IDBCreateCommand,
|
|
cProps, rgProps, (IUnknown **)&pIDBCC), S_OK,
|
|
E_NOINTERFACE, DB_E_ERRORSOCCURRED)
|
|
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
TESTC_(pIDBCC->CreateCommand(NULL, IID_ICommandStream, (IUnknown**)&pICS), S_OK)
|
|
TESTC(DefTest(pICS))
|
|
|
|
CLEANUP:
|
|
FreeProperties(&cProps, &rgProps);
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(24)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: pGuidDialect is NULL
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_24()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, NULL, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQL && pwszSQLGet, TRUE);
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(25)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: piid is NULL
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_25()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(NULL, &guid, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQL && pwszSQLGet, TRUE);
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(26)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: piid & pGuidDialect are NULL
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_26()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(NULL, NULL, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQL && pwszSQLGet, TRUE);
|
|
COMPARE(wcscmp(pwszSQL, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(27)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get an empty stream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_27()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cRead = 0;
|
|
WCHAR* pwszSQLGet;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
//Create the stream object, but don't write to it.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQLGet, NULL);
|
|
|
|
//Create the stream object, but don't write to it.
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, NULL), S_OK, E_NOINTERFACE)
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQLGet, NULL);
|
|
}
|
|
|
|
//Create the stream object, but don't write to it.
|
|
TEST2C_(hr = SetCmdStream(IID_ILockBytes, DBGUID_DEFAULT, NULL), S_OK, E_NOINTERFACE)
|
|
|
|
if(hr == S_OK)
|
|
{
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
COMPARE(pwszSQLGet, NULL);
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(28)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get a very large stream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_28()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG i;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
WCHAR* pwszSQLLong = NULL;
|
|
ULONG cWrote = 0;
|
|
ULONG ulLen = 0;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_COLLISTFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
ulLen = (ULONG)wcslen(pwszSQL);
|
|
|
|
hr = m_pStorageSet->Write(wszByteOrder, 2, NULL);
|
|
|
|
for(i=0; i<100; i++)
|
|
hr = m_pStorageSet->Write(pwszSQL, (ulLen)*sizeof(WCHAR), &cWrote);
|
|
|
|
hr = m_pStorageSet->Write(pwszSQL, (ulLen)*sizeof(WCHAR), &cWrote);
|
|
m_pStorageSet->Seek(0);
|
|
|
|
SAFE_ALLOC(pwszSQLLong, WCHAR, (101*ulLen)+1);
|
|
wcscpy(pwszSQLLong, pwszSQL);
|
|
for(i=0; i<100; i++)
|
|
wcscat(pwszSQLLong, pwszSQL);
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(NULL, &guid, &pwszSQLGet), S_OK)
|
|
|
|
TESTC(pwszSQLLong && pwszSQLGet)
|
|
COMPARE(wcscmp(pwszSQLLong, pwszSQLGet), 0);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLLong);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(29)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: test limitation of using ISequentialStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_29()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ISequentialStream* pIS1 = NULL;
|
|
ISequentialStream* pIS2 = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ2), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS1), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pIS1, IID_ISequentialStream))
|
|
|
|
TEST2C_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS2), S_OK, DB_E_ERRORSINCOMMAND)
|
|
//Verify that query2 was executed.
|
|
if(hr == S_OK)
|
|
{
|
|
TESTC(VerifyQuery2(pIS2, IID_ISequentialStream))
|
|
odtLog<<L"INFO: An ISequentialStream command can be executed multiple times.\n";
|
|
}
|
|
else
|
|
odtLog<<L"INFO: An ISequentialStream command CANNOT be executed multiple times.\n";
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pIS1);
|
|
SAFE_RELEASE(pIS2);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(30)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, SetCmdStream, GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_30()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(31)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, SetCmdStream (different cmd), GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_31()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_SETSTG;
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_COLLISTFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(32)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, SetCmdStream (different IID), GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_32()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
HRESULT hrSet = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQL2 = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_COLLISTFROMTBL, m_pTable->GetTableName(), &pwszSQL2), S_OK)
|
|
|
|
RELEASE_SETSTG;
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hrSet = SetCmdStream(IID_ILockBytes, DBGUID_DEFAULT, pwszSQL2), S_OK, E_NOINTERFACE)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
if(hrSet == S_OK)
|
|
{
|
|
COMPARE(iid, IID_ILockBytes);
|
|
TESTC(pwszSQL2 && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL2, pwszSQLGet) == 0)
|
|
}
|
|
else
|
|
{
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQL2);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(33)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, GetCmdStream, GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_33()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG i;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
for(i=0; i<5; i++)
|
|
{
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
RELEASE_GETSTG;
|
|
SAFE_FREE(pwszSQLGet);
|
|
}
|
|
|
|
//Set same command, but with different iid.
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, NULL), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
for(i=0; i<5; i++)
|
|
{
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_IStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
RELEASE_GETSTG;
|
|
SAFE_FREE(pwszSQLGet);
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(34)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdText, SetCmdStream, GetCmdText, GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_34()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
WCHAR* pwszCmd = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->GetCommandText(&guid, &pwszCmd), DB_E_CANTTRANSLATE)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(35)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, SetCmdText, GetCmdStream, GetCmdText
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_35()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_CANTTRANSLATE)
|
|
|
|
TEST2C_(hr = m_pICommandText->GetCommandText(&guid, &pwszSQLGet), S_OK, DB_S_DIALECTIGNORED)
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(36)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, SetCmdText (make call fail), GetCmdStream succeeds.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_36()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DSO, pwszSQL), DB_E_DIALECTNOTSUPPORTED)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(37)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdText, SetCmdStream (make call fail), GetCmdText succeeds.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_37()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DSO, pwszSQL), DB_E_DIALECTNOTSUPPORTED)
|
|
|
|
TESTC_(hr = m_pICommandText->GetCommandText(&guid, &pwszSQLGet), S_OK)
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(38)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_S_DIALECTIGNORED: Set and Get with different GUIDS
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_38()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_SQL;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandStream->GetCommandStream(&iid, &guid, (IUnknown**)&m_pStorageGet), DB_S_DIALECTIGNORED)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
COMPARE(m_pStorageGet != NULL, TRUE);
|
|
|
|
TESTC_(hr = Read(&pwszSQLGet), S_OK)
|
|
|
|
TESTC(pwszSQL && pwszSQLGet)
|
|
TESTC(wcscmp(pwszSQL, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(39)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_INVALIDARG: ppCommandStream is NULL
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_39()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid = IID_IRowset;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandStream->GetCommandStream(&iid, &guid, NULL), E_INVALIDARG)
|
|
|
|
COMPARE(guid, GUIDNULL);
|
|
COMPARE(iid, IID_NULL);
|
|
|
|
iid = IID_IRowset;
|
|
TESTC_(hr = m_pICommandStream->GetCommandStream(&iid, NULL, NULL), E_INVALIDARG)
|
|
COMPARE(iid, IID_NULL);
|
|
|
|
guid = DBGUID_DEFAULT;
|
|
TESTC_(hr = m_pICommandStream->GetCommandStream(NULL, &guid, NULL), E_INVALIDARG)
|
|
COMPARE(guid, GUIDNULL);
|
|
|
|
TESTC_(hr = m_pICommandStream->GetCommandStream(NULL, NULL, NULL), E_INVALIDARG)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(40)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_NOCOMMAND: SetCmdStream, SetCmdStream(NULL), GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_40()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Set a command stream.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//reset cmd stream.
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_NOCOMMAND)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(41)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_NOCOMMAND: SetCmdStream, SetCmdText (NULL), GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_41()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Set a command stream.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//reset cmd stream.
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_NOCOMMAND)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(42)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_CANTTRANSLATE: SetCmdText, GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCGetCmdStream::Variation_42()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
WCHAR* pwszCmd = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_CANTTRANSLATE)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
BOOL TCGetCmdStream::Terminate()
|
|
{
|
|
// TO DO: Add your own code here
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(CCmdStream::Terminate());
|
|
} // }}
|
|
// }} TCW_TERMINATE_METHOD_END
|
|
// }} TCW_TC_PROTOTYPE_END
|
|
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCSetCmdStream)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCSetCmdStream - SetCommandStream Test Case
|
|
//| Created: 11/15/1999
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCSetCmdStream::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(CCmdStream::Init())
|
|
// }}
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set cmd props. SetCmdStream. Execute.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_1()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ICommand* pICommand = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
SetProperty(DBPROP_IRowset, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
//SetProperty(DBPROP_CANFETCHBACKWARDS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
//SetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC(VerifyInterface(m_pICommandStream, IID_ICommand,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICommand))
|
|
|
|
TESTC_(pICommand->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pICommand);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Execute CmdText, release rowset, SetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_2()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszCmd = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
IRowset* pIR = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_IRowset, NULL, &lRA, (IUnknown**)&pIR), S_OK)
|
|
TESTC(DefTestInterface(pIR))
|
|
SAFE_RELEASE(pIR);
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIR);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set/Get/Execute. Verify cmd stream object lifetime
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_3()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ULONG cRef = 0;
|
|
ULONG ulLen = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
IDBCreateSession* pIDBCS = NULL;
|
|
IDBCreateCommand* pIDBCC = NULL;
|
|
ICommand* pICmd = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
TESTC_(GetModInfo()->CreateProvider(NULL, IID_IDBCreateSession,
|
|
(IUnknown**)&pIDBCS, CREATEDSO_SETPROPERTIES|CREATEDSO_INITIALIZE), S_OK)
|
|
|
|
TESTC_(pIDBCS->CreateSession(NULL, IID_IDBCreateCommand,
|
|
(IUnknown**)&pIDBCC), S_OK)
|
|
|
|
TESTC_(pIDBCC->CreateCommand(NULL, IID_ICommandStream, (IUnknown**)&pICS), S_OK)
|
|
TESTC(VerifyInterface(pICS, IID_ICommand,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICmd))
|
|
|
|
ALLOC_SETSTG;
|
|
cRef = m_pStorageSet->GetRefCount();
|
|
|
|
TESTC_(Write(m_pwszQ1), S_OK)
|
|
TESTC_(hr = pICS->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, (ISequentialStream*)m_pStorageSet), S_OK)
|
|
|
|
TEST2C_(hr = pICS->GetCommandStream(&iid, &guid, (IUnknown**)&pISS), S_OK, DB_S_DIALECTIGNORED)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
SAFE_RELEASE(pISS);
|
|
|
|
TESTC_(pICmd->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
SAFE_RELEASE(pIDBCS);
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
SAFE_RELEASE(pICmd);
|
|
SAFE_RELEASE(pISS);
|
|
|
|
COMPARE(m_pStorageSet->GetRefCount(), cRef);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIDBCS);
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
SAFE_RELEASE(pICmd);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(4)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Execute some privlib queries and verify.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_4()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
IRowset* pIRowset = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//Apart from S_OK, can also expect to get -
|
|
//DB_E_ERRORSINCOMMAND, since the type of command may not match with what DBGUID_DEFAULT stand for.
|
|
//E_NOINTERFACE, since we are asking for IID_IRowset and Execute after SetCmdStream may only support returning stream objects.
|
|
TEST3C_(hr = m_pICommandText->Execute(NULL, IID_IRowset, NULL, &lRA, (IUnknown**)&pIRowset), S_OK, DB_E_ERRORSINCOMMAND, E_NOINTERFACE)
|
|
|
|
if(hr == S_OK)
|
|
TESTC(VerifyRowset(SELECT_ALLFROMTBL, pIRowset))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIRowset);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(5)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: pCommandStream is NULL (cmd state reset)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_5()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Set a command stream.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//reset cmd stream.
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_NOCOMMAND)
|
|
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
//Set a command stream.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
//reset cmd stream multiple times.
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_NOCOMMAND)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(6)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream with stream containing 2 cmds. Ptr on 2nd.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_6()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
ULONG cWrote = 0;
|
|
ULONG ulLen = 0;
|
|
ULONG ulLen2 = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Write first command to stream.
|
|
ulLen = (ULONG)wcslen(pwszSQL);
|
|
hr = m_pStorageSet->Write(wszByteOrder, 2, NULL);
|
|
hr = m_pStorageSet->Write(pwszSQL, (ulLen)*sizeof(WCHAR), &cWrote);
|
|
|
|
//Write second command to stream.
|
|
ulLen2 = (ULONG)wcslen(m_pwszQ1);
|
|
hr = m_pStorageSet->Write(L";", 2, NULL);
|
|
hr = m_pStorageSet->Write(wszByteOrder, 2, NULL);
|
|
hr = m_pStorageSet->Write(m_pwszQ1, (ulLen2)*sizeof(WCHAR), &cWrote);
|
|
|
|
//Seek to beginning of second command.
|
|
m_pStorageSet->Seek(2 + (ulLen)*sizeof(WCHAR) + 2);
|
|
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, (ISequentialStream*)m_pStorageSet), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(7)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream & Execute diffr queries on diffr cmd objs.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_7()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ICommand* pICommand = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
ISequentialStream* pISS2 = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
//Create another cmd object.
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand, (IUnknown**)&pICommand), S_OK)
|
|
TESTC(VerifyInterface(pICommand, IID_ICommandStream,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICS))
|
|
|
|
//Set stream on first command.
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
RELEASE_SETSTG;
|
|
ALLOC_SETSTG;
|
|
|
|
//Set stream on second command.
|
|
TESTC_(hr = Write(m_pwszQ2), S_OK)
|
|
TESTC_(hr = pICS->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, (ISequentialStream*)m_pStorageSet), S_OK)
|
|
|
|
//Execute command on first.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
//Set the encoding on second command also to UTF-16
|
|
CHECK(SetEncdProp(UTF16, (IUnknown*)pICommand), S_OK);
|
|
|
|
//Execute command on second.
|
|
TESTC_(pICommand->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS2), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pISS2, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pICommand);
|
|
SAFE_RELEASE(pICS);
|
|
SAFE_RELEASE(pISS);
|
|
SAFE_RELEASE(pISS2);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(8)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, Prepare, GetColInfo.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_8()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
DBORDINAL cCols = 0;
|
|
DBCOLUMNINFO* rgInfo = NULL;
|
|
WCHAR* pwszBuf = NULL;
|
|
IColumnsInfo* pICF = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC(PrepCmd())
|
|
|
|
TESTC(VerifyInterface(m_pICommandStream, IID_IColumnsInfo,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICF))
|
|
|
|
CHECK(pICF->GetColumnInfo(&cCols, &rgInfo, &pwszBuf), S_OK);
|
|
COMPARE(!cCols && !rgInfo && !pwszBuf, TRUE);
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_FREE(rgInfo);
|
|
SAFE_FREE(pwszBuf);
|
|
SAFE_RELEASE(pICF);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(9)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, Prepare, GetColumnsRowset.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_9()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
DBCOUNTITEM cRows = 0;
|
|
HROW* rghRows = NULL;
|
|
IRowset* pIR = NULL;
|
|
IColumnsRowset* pICR = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC(PrepCmd())
|
|
|
|
TESTC_PROVIDER(VerifyInterface(m_pICommandStream, IID_IColumnsRowset,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICR))
|
|
|
|
TESTC_(pICR->GetColumnsRowset(NULL, 0, NULL, IID_IRowset,
|
|
0, NULL, (IUnknown**)&pIR), S_OK)
|
|
TESTC(pIR != NULL)
|
|
TESTC_(pIR->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRows,
|
|
&rghRows), DB_S_ENDOFROWSET)
|
|
COMPARE(cRows, 0);
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_FREE(rghRows);
|
|
SAFE_RELEASE(pICR);
|
|
SAFE_RELEASE(pIR);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(10)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Implement stream on a large file. SetCmdStream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_10()
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(11)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Aggregate stream got from Execute.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_11()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
IUnknown* pIUnkInner = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
SetProperty(DBPROP_ISequentialStream, DBPROPSET_ROWSET,
|
|
&cPropSets, &rgPropSets);
|
|
CHECK(hr = SetCmdProp(rgPropSets), S_OK);
|
|
|
|
CAggregate Aggregate(m_pICommandText);
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(&Aggregate, IID_IUnknown, NULL, &lRA, (IUnknown**)&pIUnkInner), S_OK)
|
|
Aggregate.SetUnkInner(pIUnkInner);
|
|
|
|
//Verify Aggregation.
|
|
TESTC(Aggregate.VerifyAggregationQI(hr, IID_ISequentialStream))
|
|
|
|
TESTC(VerifyInterface(pIUnkInner, IID_ISequentialStream,
|
|
STREAM_INTERFACE,(IUnknown **)&pISS))
|
|
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
if(rgPropSets)
|
|
{
|
|
VariantInit(&rgPropSets[0].rgProperties[0].vValue);
|
|
CHECK(hr = SetCmdProp(rgPropSets), S_OK);
|
|
}
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_RELEASE(pIUnkInner);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(12)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_ERRORSINCOMMAND: SetCmdStream with an embedded NULL terminator.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_12()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
ULONG cWrote = 0;
|
|
ULONG ulLen = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Write first command to stream.
|
|
ulLen = (ULONG)wcslen(pwszSQL);
|
|
hr = m_pStorageSet->Write(wszByteOrder, 2, NULL);
|
|
hr = m_pStorageSet->Write(pwszSQL, (ulLen)*sizeof(WCHAR), &cWrote);
|
|
|
|
//Seek to middle of command and put a NULL term char.
|
|
m_pStorageSet->Seek(2 + (ulLen)*sizeof(WCHAR)/2);
|
|
m_pStorageSet->Write(L"", 2, NULL);
|
|
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, (ISequentialStream*)m_pStorageSet), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), DB_E_ERRORSINCOMMAND)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(13)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_ERRORSINCOMMAND: Set unicode stream without BOM
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_13()
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(14)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set stream as ansi - no BOM
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_14()
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(15)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Set DBPROP_DEFERRED.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_15()
|
|
{
|
|
// TO DO: Add your own code here
|
|
return TRUE;
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(16)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Call SetCmdStream so it fails. Ref cnt unchanged.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_16()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cRef=0;
|
|
WCHAR* pwszSQL = NULL;
|
|
IRowset* pIR = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
cRef = m_pStorageSet->GetRefCount();
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(m_pTable->ExecuteCommand(SELECT_ALLFROMTBL,
|
|
IID_IRowset, NULL, NULL, NULL, NULL,
|
|
EXECUTE_IFNOERROR, 0, NULL, NULL, (IUnknown**)&pIR,
|
|
(ICommand**)&m_pICommandText), S_OK)
|
|
TESTC(pIR != NULL)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), DB_E_OBJECTOPEN)
|
|
COMPARE(m_pStorageSet->GetRefCount(), cRef);
|
|
SAFE_RELEASE(pIR);
|
|
|
|
TESTC_(hr = SetCmdStream(IID_IRowset, DBGUID_DEFAULT, pwszSQL), E_NOINTERFACE)
|
|
COMPARE(m_pStorageSet->GetRefCount(), cRef);
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DSO, pwszSQL), DB_E_DIALECTNOTSUPPORTED)
|
|
COMPARE(m_pStorageSet->GetRefCount(), cRef);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIR);
|
|
RELEASE_SETSTG;
|
|
RELEASE_GETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(17)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Release all objects & verify no ref cnts left on stream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_17()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cRef = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
IDBCreateSession* pIDBCS = NULL;
|
|
IDBCreateCommand* pIDBCC = NULL;
|
|
ICommandStream* pICS = NULL;
|
|
|
|
TESTC_(GetModInfo()->CreateProvider(NULL, IID_IDBCreateSession,
|
|
(IUnknown**)&pIDBCS, CREATEDSO_SETPROPERTIES|CREATEDSO_INITIALIZE), S_OK)
|
|
|
|
TESTC_(pIDBCS->CreateSession(NULL, IID_IDBCreateCommand,
|
|
(IUnknown**)&pIDBCC), S_OK)
|
|
|
|
TESTC_(pIDBCC->CreateCommand(NULL, IID_ICommandStream, (IUnknown**)&pICS), S_OK)
|
|
|
|
ALLOC_SETSTG;
|
|
cRef = m_pStorageSet->GetRefCount();
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
//Write command to stream.
|
|
TESTC_(Write(pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = pICS->SetCommandStream(IID_ISequentialStream, DBGUID_DEFAULT, (ISequentialStream*)m_pStorageSet), S_OK)
|
|
|
|
SAFE_RELEASE(pIDBCS);
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
|
|
COMPARE(m_pStorageSet->GetRefCount(), cRef);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIDBCS);
|
|
SAFE_RELEASE(pIDBCC);
|
|
SAFE_RELEASE(pICS);
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(18)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, GetCmdStream, SetCmdStream with stream got. Execute.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_18()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandStream->SetCommandStream(IID_ISequentialStream,
|
|
DBGUID_DEFAULT, (ISequentialStream*)m_pStorageGet), S_OK)
|
|
|
|
//Execute command on second.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(19)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, Execute, GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_19()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ICommand* pICommand = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC(VerifyInterface(m_pICommandStream, IID_ICommand,
|
|
COMMAND_INTERFACE,(IUnknown **)&pICommand))
|
|
|
|
TESTC_(pICommand->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
COMPARE(iid, IID_ISequentialStream);
|
|
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pICommand);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(20)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, GetCmdStream, Execute
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_20()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, &pwszSQLGet), S_OK)
|
|
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(21)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, Execute, Execute
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_21()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ISequentialStream* pIS1 = NULL;
|
|
ISequentialStream* pIS2 = NULL;
|
|
ISequentialStream* pIS3 = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, m_pwszQ2), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS1), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pIS1, IID_ISequentialStream))
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS2), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pIS2, IID_ISequentialStream))
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS3), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pIS3, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pIS1);
|
|
SAFE_RELEASE(pIS2);
|
|
SAFE_RELEASE(pIS3);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(22)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdText, SetCmdStream, Execute
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_22()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
WCHAR* pwszSQL = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(23)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: SetCmdStream, GetCmdStream, SetCmdText, Execute. Read got stream.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_23()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
IID iid;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
WCHAR* pwszSQL = NULL;
|
|
WCHAR* pwszSQLGet = NULL;
|
|
IRowset* pIR = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), S_OK)
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_IRowset, NULL, &lRA, (IUnknown**)&pIR), S_OK)
|
|
|
|
TESTC(VerifyRowset(SELECT_ALLFROMTBL, pIR))
|
|
|
|
//Read the got stream.
|
|
TESTC_(hr = Read(&pwszSQLGet), S_OK)
|
|
TESTC(m_pwszQ1 && pwszSQLGet)
|
|
TESTC(wcscmp(m_pwszQ1, pwszSQLGet) == 0)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_FREE(pwszSQLGet);
|
|
SAFE_RELEASE(pIR);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(24)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK: Ask for IUnknown on Execute.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_24()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
IUnknown* pIUnk = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
SetProperty(DBPROP_ISequentialStream, DBPROPSET_ROWSET,
|
|
&cPropSets, &rgPropSets);
|
|
CHECK(hr = SetCmdProp(rgPropSets), S_OK);
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
//Execute asking for IID_IUnknown on the stream.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_IUnknown, NULL, &lRA, (IUnknown**)&pIUnk), S_OK)
|
|
|
|
TESTC(VerifyInterface(pIUnk, IID_ISequentialStream,
|
|
STREAM_INTERFACE,(IUnknown **)&pISS))
|
|
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
if(rgPropSets)
|
|
{
|
|
VariantInit(&rgPropSets[0].rgProperties[0].vValue);
|
|
CHECK(hr = SetCmdProp(rgPropSets), S_OK);
|
|
}
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_FREE(pwszSQL);
|
|
SAFE_RELEASE(pIUnk);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(25)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DBPROP_OUTPUTSTREAM - ISequentialStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_25()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
m_pStorageGet = new CStorage();
|
|
TESTC(m_pStorageGet != NULL)
|
|
|
|
SetProperty(DBPROP_OUTPUTSTREAM, DBPROPSET_STREAM, &cPropSets, &rgPropSets, (void*)m_pStorageGet, DBTYPE_IUNKNOWN);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
if(hr!=S_OK)
|
|
{
|
|
odtLog<<L"INFO: DBPROP_OUTPUTSTREAM is not supported.\n";
|
|
goto CLEANUP;
|
|
}
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
//Call Execute with ppRowset=NULL.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
|
|
TESTC(VerifyEqualInterface(pISS, (ISequentialStream*)m_pStorageGet))
|
|
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1((ISequentialStream*)m_pStorageGet, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
if(rgPropSets)
|
|
{
|
|
V_VT(&rgPropSets[0].rgProperties[0].vValue) = VT_EMPTY;
|
|
CHECKW(SetCmdProp(rgPropSets), S_OK);
|
|
}
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(26)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DBPROP_OUTPUTSTREAM - ISequentialStream (NULL ppRowset)
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_26()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
m_pStorageGet = new CStorage();
|
|
TESTC(m_pStorageGet != NULL)
|
|
|
|
SetProperty(DBPROP_OUTPUTSTREAM, DBPROPSET_STREAM, &cPropSets, &rgPropSets, (void*)m_pStorageGet, DBTYPE_IUNKNOWN);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
if(hr!=S_OK)
|
|
{
|
|
odtLog<<L"INFO: DBPROP_OUTPUTSTREAM is not supported.\n";
|
|
goto CLEANUP;
|
|
}
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
//Call Execute with ppRowset=NULL.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, NULL), S_OK)
|
|
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1((ISequentialStream*)m_pStorageGet, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
if(rgPropSets)
|
|
{
|
|
V_VT(&rgPropSets[0].rgProperties[0].vValue) = VT_EMPTY;
|
|
CHECKW(SetCmdProp(rgPropSets), S_OK);
|
|
}
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(27)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DBPROP_OUTPUTSTREAM - IStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_27()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET* rgPropSets = NULL;
|
|
IStream* pIS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
m_pStorageGet = new CStorage();
|
|
TESTC(m_pStorageGet != NULL)
|
|
|
|
SetProperty(DBPROP_OUTPUTSTREAM, DBPROPSET_STREAM, &cPropSets, &rgPropSets, (void*)m_pStorageGet, DBTYPE_IUNKNOWN);
|
|
hr = SetCmdProp(rgPropSets);
|
|
COMPARE(hr==S_OK || hr==DB_E_ERRORSOCCURRED, TRUE);
|
|
if(hr!=S_OK)
|
|
{
|
|
odtLog<<L"INFO: DBPROP_OUTPUTSTREAM is not supported.\n";
|
|
goto CLEANUP;
|
|
}
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
//Call Execute with valid ppRowset.
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_IStream, NULL, &lRA, (IUnknown**)&pIS), S_OK)
|
|
TESTC(pIS != NULL)
|
|
|
|
TESTC(VerifyEqualInterface(pIS, (IStream*)m_pStorageGet))
|
|
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1((IStream*)m_pStorageGet, IID_IStream))
|
|
|
|
CLEANUP:
|
|
if(rgPropSets)
|
|
{
|
|
V_VT(&rgPropSets[0].rgProperties[0].vValue) = VT_EMPTY;
|
|
CHECKW(SetCmdProp(rgPropSets), S_OK);
|
|
}
|
|
FreeProperties(&cPropSets, &rgPropSets);
|
|
SAFE_RELEASE(pIS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(28)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DBPROP_OUTPUTENCODING - UTF-8
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_28()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cRead = 0;
|
|
ULONG ulReadIncr = READ_INCR;
|
|
WCHAR* pwszCmd = NULL;
|
|
CHAR* pszCmd = NULL;
|
|
CHAR* pszEnd = NULL;
|
|
BOOL fEnd = FALSE;
|
|
DBROWCOUNT lRA = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
TESTC_(SetEncdProp(UTF8), S_OK)
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_SETSTG;
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ2), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
|
|
//Verify that query2 was executed.
|
|
|
|
SAFE_ALLOC(pszCmd, CHAR, ulReadIncr);
|
|
|
|
hr = pISS->Read(pszCmd, ulReadIncr, &cRead);
|
|
if(cRead < ulReadIncr)
|
|
{
|
|
fEnd = TRUE;
|
|
pszEnd = (CHAR*)pszCmd + cRead;
|
|
}
|
|
|
|
while(!fEnd)
|
|
{
|
|
cRead = 0;
|
|
ulReadIncr += READ_INCR;
|
|
SAFE_REALLOC(pszCmd, CHAR, ulReadIncr);
|
|
hr = pISS->Read((BYTE*)pszCmd +ulReadIncr -READ_INCR, READ_INCR, &cRead);
|
|
if(cRead < READ_INCR)
|
|
{
|
|
fEnd = TRUE;
|
|
pszEnd = (CHAR*)pszCmd +ulReadIncr -READ_INCR + cRead;
|
|
}
|
|
}
|
|
|
|
memset((BYTE*)pszEnd, 0, 1);
|
|
|
|
pwszCmd = ConvertToWCHAR(pszCmd);
|
|
TESTC(pwszCmd != NULL)
|
|
|
|
TESTC(wcsstr(pwszCmd, m_pwszQ2) != NULL)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszCmd);
|
|
SAFE_FREE(pszCmd);
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(29)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DBPROP_OUTPUTENCODING - UTF-16
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_29()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
TESTC_(SetEncdProp(UTF16), S_OK)
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_SETSTG;
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ2), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pISS, IID_ISequentialStream))
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(30)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_NOINTERFACE: iid passed in does not match object
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_30()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
//Make a str4eam object that can only be QIed for ILockBytes.
|
|
ALLOC_SETSTG;
|
|
m_pStorageSet->SetQISeqStream(FALSE);
|
|
m_pStorageSet->SetQIStream(FALSE);
|
|
m_pStorageSet->SetQILockBytes(TRUE);
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), E_NOINTERFACE)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(31)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_NOINTERFACE: iid is IRowset & IRow.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_31()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_IRow, DBGUID_DEFAULT, pwszSQL), E_NOINTERFACE)
|
|
TESTC_(hr = SetCmdStream(IID_IRowset, DBGUID_DEFAULT, pwszSQL), E_NOINTERFACE)
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(32)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_CANTTRANSLATE: SetCmdStream, GetCmdText
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_32()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
GUID guid = DBGUID_DEFAULT;
|
|
GUID guidNull = DB_NULLGUID;
|
|
WCHAR* pwszCmd = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->GetCommandText(&guid, &pwszCmd), DB_E_CANTTRANSLATE)
|
|
COMPARE(guid, guidNull);
|
|
COMPARE(pwszCmd, NULL);
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(33)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_DIALECTNOTSUPPORTED: Use some bugs guids & DBGUID_NULL
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_33()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
GUID guidNull = DB_NULLGUID;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
CHECK(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DSO, m_pwszQ1), DB_E_DIALECTNOTSUPPORTED);
|
|
CHECK(hr = SetCmdStream(IID_ISequentialStream, DBGUID_ROWSET, m_pwszQ1), DB_E_DIALECTNOTSUPPORTED);
|
|
CHECK(hr = SetCmdStream(IID_ISequentialStream, guidNull, m_pwszQ1), DB_E_DIALECTNOTSUPPORTED);
|
|
|
|
CLEANUP:
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(34)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_DIALECTNOTSUPPORTED (or S_OK): use DBGUID_SQL.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_34()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_SQL, m_pwszQ1), S_OK, DB_E_DIALECTNOTSUPPORTED);
|
|
|
|
if(hr == S_OK)
|
|
odtLog<<L"INFO: DBGUID_SQL is supported on SetCommandStream.\n";
|
|
else
|
|
odtLog<<L"INFO: DBGUID_SQL is NOT supported on SetCommandStream.\n";
|
|
|
|
CLEANUP:
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(35)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_OBJECTOPEN: Keeping a result stream open, call Set.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_35()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ISequentialStream* pISS = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, m_pwszQ1), S_OK)
|
|
|
|
TESTC_(m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pISS), S_OK)
|
|
//Verify that query1 was executed.
|
|
TESTC(VerifyQuery1(pISS, IID_ISequentialStream))
|
|
|
|
TESTC_(hr = SetCmdStream(IID_ISequentialStream, DBGUID_DEFAULT, NULL), DB_E_OBJECTOPEN)
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pISS);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(36)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Clear previous error object.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_36()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
DBROWCOUNT lRA = 0;
|
|
ULONG cRecords = 0;
|
|
IColumnsInfo* pIC = NULL;
|
|
ISequentialStream* pIS1 = NULL;
|
|
IErrorInfo* pIEI = NULL;
|
|
IErrorRecords* pIER = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TEST2C_(hr = SetCmdStream(IID_IStream, DBGUID_DEFAULT, m_pwszQ2), S_OK, E_NOINTERFACE)
|
|
TESTC_PROVIDER(hr == S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->Execute(NULL, IID_ISequentialStream, NULL, &lRA, (IUnknown**)&pIS1), S_OK)
|
|
|
|
//Cause an error.
|
|
TESTC(VerifyInterface(m_pICommandText, IID_IColumnsInfo,
|
|
COMMAND_INTERFACE,(IUnknown **)&pIC))
|
|
TESTC_(pIC->GetColumnInfo(NULL, NULL, NULL), E_INVALIDARG)
|
|
|
|
//Verify that query2 was executed.
|
|
TESTC(VerifyQuery2(pIS1, IID_ISequentialStream))
|
|
|
|
//When stream was read above it returned S_OK. So, the error info
|
|
//should have been cleared.
|
|
//Get the IErrorInfo interface.
|
|
hr = GetErrorInfo(0, &pIEI) ;
|
|
if(hr == S_FALSE)
|
|
{
|
|
odtLog<<L"ErrorInfo is not supported.\n";
|
|
goto CLEANUP;
|
|
}
|
|
|
|
CLEANUP:
|
|
SAFE_RELEASE(pIC);
|
|
SAFE_RELEASE(pIS1);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(37)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Extended error test - GetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_37()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
IID iid;
|
|
GUID guid;
|
|
WCHAR* pwszCmd = NULL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = m_pICommandText->SetCommandText(DBGUID_DEFAULT, pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = GetCmdStream(&iid, &guid, NULL), DB_E_CANTTRANSLATE)
|
|
|
|
TESTC(XCHECK(m_pICommandStream, IID_ICommandStream, hr));
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_GETSTG;
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(38)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Extended error test - SetCmdStream
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCSetCmdStream::Variation_38()
|
|
{
|
|
TBEGIN
|
|
HRESULT hr = E_FAIL;
|
|
WCHAR* pwszSQL = NULL;
|
|
|
|
ALLOC_SETSTG;
|
|
|
|
TESTC_(hr = m_pTable->CreateSQLStmt(SELECT_ALLFROMTBL, m_pTable->GetTableName(), &pwszSQL), S_OK)
|
|
|
|
TESTC_(hr = SetCmdStream(IID_IRowset, DBGUID_DEFAULT, pwszSQL), E_NOINTERFACE)
|
|
|
|
TESTC(XCHECK(m_pICommandStream, IID_ICommandStream, hr));
|
|
|
|
CLEANUP:
|
|
SAFE_FREE(pwszSQL);
|
|
RELEASE_SETSTG;
|
|
TRETURN
|
|
}
|
|
// }} TCW_VAR_PROTOTYPE_END
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
BOOL TCSetCmdStream::Terminate()
|
|
{
|
|
// TO DO: Add your own code here
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(CCmdStream::Terminate());
|
|
} // }}
|
|
// }} TCW_TERMINATE_METHOD_END
|
|
// }} TCW_TC_PROTOTYPE_END
|