Windows/Windows-classic-samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Windows-classic-samples/Samples/Win7Samples/dataaccess/oledb_conformance/oledb/igetsession/igetsession.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

1964 lines
52 KiB
C++
Raw Blame History

//*--------------------------------------------------------------------
//
// This is the Test Module for IGetSession interface, which is a
// mandatory interface on ROW objects.
//
// WARNING:
// PLEASE USE THE TEST CASE WIZARD TO ADD/DELETE TESTS AND VARIATIONS!
//
// Copyright (C) 1994-2000 Microsoft Corporation
//*---------------------------------------------------------------------
#include "MODStandard.hpp"
#include "IGetSession.h"
#include "ExtraLib.h"
//*---------------------------------------------------------------------
// Module Values
//*---------------------------------------------------------------------
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0xb39cade0, 0x57e5, 0x11d2, { 0x88, 0xd7, 0x00, 0x60, 0x08, 0x9f, 0xc4, 0x66} };
DECLARE_MODULE_NAME("IGetSession");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("Test Module for IGetSession interface.");
DECLARE_MODULE_VERSION(1);
// TCW_WizardVersion(2)
// TCW_Automation(FALSE)
// }} TCW_MODULE_GLOBALS_END
//*---------------------------------------------------------------------
// @func Module level initialization routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleInit(CThisTestModule * pThisTestModule)
{
ULONG_PTR ulVal=0;
if(CommonModuleInit(pThisTestModule))
{
if(GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &ulVal))
{
if((ulVal & DBPROPVAL_OO_ROWOBJECT) ||
(ulVal & DBPROPVAL_OO_SINGLETON) ||
(ulVal & DBPROPVAL_OO_DIRECTBIND) )
return TEST_PASS;
else
return TEST_SKIPPED;
}
else
return TEST_SKIPPED;
}
return FALSE;
}
//*---------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
return CommonModuleTerminate(pThisTestModule);
}
////////////////////////////////////////////////////////////////////////
// TCBase - Class for reusing Test Cases.
// This is one of the base classes from which all the Test Case
// classes will inherit. It is used to duplicate test cases, yet
// maintain some sort of distinct identity for each.
//
////////////////////////////////////////////////////////////////////////
class TCBase
{
public:
//constructor
TCBase() { SetTestCaseParam(TC_RowsetByOpenRowset); }
//Set the m_fWarning and m_fBinder flags.
virtual void SetTestCaseParam(ETESTCASE eTestCase = TC_RowsetByOpenRowset)
{
m_eTestCase = eTestCase;
m_fWarning = FALSE;
m_fBinder = FALSE;
switch(eTestCase)
{
case TC_RowsetByOpenRowset:
break;
case TC_RowsetByCommand:
break;
case TC_SchemaRowset:
break;
case TC_ColumnsRowset:
m_fWarning = TRUE;
break;
case TC_DirectBindOnRootBinder:
case TC_DirectBindOnProvider:
case TC_GetSourceRow:
m_fWarning = TRUE;
m_fBinder = TRUE;
break;
case TC_OpenRowsetDirect:
break;
case TC_CommandDirect:
break;
default:
ASSERT(!L"Unhandled Type...");
break;
};
}
//data
ETESTCASE m_eTestCase;
//This indicates if the variations in a particular test case would
//flag the return code DB_E_NOSOURCEOBJECT as a warning (or error).
BOOL m_fWarning;
//Indicates if Direct Binding was involved in obtaining the row
//object being tested in a particular test case.
BOOL m_fBinder;
};
////////////////////////////////////////////////////////////////////////
// TCTransactions - Class for Transaction Test Case.
//
////////////////////////////////////////////////////////////////////////
class TCTransactions : public CTransaction
{
public:
//constructors
TCTransactions(WCHAR* pwszTestCaseName = INVALID(WCHAR*)) : CTransaction(pwszTestCaseName) {}
int TestTxnRow(BOOL bCommit, BOOL fRetaining);
};
//*-----------------------------------------------------------------------
// @mfunc TestTxn
// Helper function for testing transaction commit/abort variations.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCTransactions::TestTxnRow(BOOL bCommit,BOOL fRetaining)
{
TBEGIN
BOOL fSuccess = FALSE;
HRESULT ExpectedHr = E_UNEXPECTED;
HRESULT hr = E_FAIL;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
ULONG cPropSets = 0;
DBPROPSET * rgPropSets = NULL;
ULONG_PTR ulVal = 0;
IGetSession * pIGetSession = NULL;
IUnknown* pSessUnk = NULL;
//Not required to set this property. Just doing it for additional testing.
SetSettableProperty(DBPROP_BOOKMARKS,DBPROPSET_ROWSET,
&cPropSets, &rgPropSets);
//Check to see if Opening ROW objects thru OpenRowset is supported.
if(!GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
(IUnknown*)m_pIDBCreateSession, &ulVal) ||
(!(ulVal & DBPROPVAL_OO_SINGLETON) && !(ulVal & DBPROPVAL_OO_ROWOBJECT)))
{
odtLog<<L"INFO: ROW objects are not supported.\n";
goto CLEANUP;
}
TESTC(StartTransaction(USE_OPENROWSET, (IUnknown **)&pIGetSession,
cPropSets, rgPropSets, NULL, ISOLATIONLEVEL_READUNCOMMITTED, TRUE))
CHECK(pIGetSession->GetSession(IID_IUnknown, (IUnknown**)&pSessUnk),S_OK);
COMPARE(DefaultObjectTesting(pSessUnk, SESSION_INTERFACE), TRUE);
COMPARE(VerifyEqualInterface(pSessUnk, m_pIOpenRowset), TRUE);
SAFE_RELEASE(pSessUnk);
if (bCommit)
TESTC(GetCommit(fRetaining))
else
TESTC(GetAbort(fRetaining))
// Make sure everything still works after commit or abort
if ((bCommit && m_fCommitPreserve) ||
((!bCommit) && m_fAbortPreserve))
ExpectedHr = S_OK;
// Test zombie
if(m_pIRowset)
CHECK(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
//Make sure everything still works after commit or abort
CHECK(hr=pIGetSession->GetSession(IID_IUnknown, (IUnknown**)&pSessUnk),ExpectedHr);
if(FAILED(hr))
TESTC(!pSessUnk)
else
TESTC(DefaultObjectTesting(pSessUnk, SESSION_INTERFACE))
CLEANUP:
if (m_pIRowset && rghRows)
CHECK(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL),S_OK);
FreeProperties(&cPropSets, &rgPropSets);
SAFE_FREE(rghRows);
SAFE_RELEASE(pSessUnk);
SAFE_RELEASE(pIGetSession);
//Return code of Commit/Abort will vary depending on whether
//or not we have an open txn, so adjust accordingly
CleanUpTransaction((fRetaining) ? S_OK : XACT_E_NOTRANSACTION);
TRETURN
} //TestTxnRow
////////////////////////////////////////////////////////////////////////
// CGetSession - Class for IGetSession Test Cases.
//
////////////////////////////////////////////////////////////////////////
class CGetSession : public CSessionObject, public TCBase
{
public:
//constructors
CGetSession(WCHAR* pwszTestCaseName = INVALID(WCHAR*));
virtual ~CGetSession() {}
//methods
virtual BOOL Init(ETESTCASE eTC=TC_RowsetByOpenRowset);
virtual BOOL Terminate();
protected:
//VARIABLES...
HRESULT m_hr;
DBCOUNTITEM m_cRowsObtained;
HROW* m_rghRows;
WCHAR* m_pwszRowURL;
CRowset* m_pCRowset;
CRowset* m_pCRowsetA;
CRowObject* m_pCRowObj;
//INTERFACES...
IBindResource* m_pIBindResource;
IUnknown* m_pImplSess;
//METHODS...
//Cleanup operation for terminating a test case.
BOOL ReleaseAll();
//Execute a select * from [table] command to obtain a rowset.
BOOL GetRowsetFromCommand(
ICommandText* pICT,
IRowset** ppIRowset);
//Test the obtained IOpenRowset interface.
BOOL testIOpenRowset(IOpenRowset* pIOpenRowset);
//Helper function for testing variations
BOOL VerifyGetSession(REFIID riid);
//Get the IBindResource on Root Binder and get a ROW URL.
BOOL GetRootBinder();
};
//----------------------------------------------------------------------
// CGetSession::CGetSession
//
CGetSession::CGetSession(WCHAR * wstrTestCaseName) : CSessionObject(wstrTestCaseName)
{
m_pwszRowURL = NULL;
m_cRowsObtained = 0;
m_rghRows = NULL;
m_pwszRowURL = NULL;
m_pCRowset = NULL;
m_pCRowsetA = NULL;
m_pCRowObj = NULL;
m_pIBindResource = NULL;
m_pImplSess = NULL;
}
//----------------------------------------------------------------------
// CGetSession::Init
//
BOOL CGetSession::Init(ETESTCASE eTC)
{
TBEGIN
HRESULT hr = E_FAIL;
IID iid = IID_IOpenRowset;
DBID dbid;
DBIMPLICITSESSION dbImplSess;
ULONG_PTR ulVal = 0;
BOOL bSingleton = FALSE;
BOOL fSkip = FALSE;
IDBCreateCommand* pIDBCC = NULL;
IDBSchemaRowset* pIDBSR = NULL;
IColumnsRowset* pIColRowset = NULL;
ICommandText* pICT = NULL;
IRowset* pIRowset = NULL;
IGetSourceRow* pIGSR = NULL;
IRow* pIRow = NULL;
IBindResource* pIBRProv = NULL;
CRowset RowsetA;
memset(&dbImplSess, 0, sizeof(DBIMPLICITSESSION));
m_pCRowset = NULL;
m_pCRowObj = NULL;
TESTC(CSessionObject::Init())
SetTable(g_pTable, DELETETABLE_NO);
m_pCRowset = new CRowset();
TESTC(m_pCRowset!=NULL)
m_pCRowObj = new CRowObject();
TESTC(m_pCRowObj!=NULL)
GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
(IUnknown*)g_pIDBInitialize, &ulVal);
//The INIT will vary depending on type of Test Case. They all involve
//getting a ROW object (by various different means) and putting it
//in m_pCRowObj.
switch(eTC)
{
//Get a Rowset using OpenRowset, and obtain a Row obj from it.
case TC_RowsetByOpenRowset:
{
VARIANT_BOOL bValue;
m_pCRowset->SetProperty(DBPROP_CANHOLDROWS);
TESTC_(m_pCRowset->CreateRowset(),S_OK);
TESTC_(m_pCRowset->GetNextRows(0, 1, &m_cRowsObtained, &m_rghRows),S_OK)
TEST3C_(hr = m_pCRowObj->CreateRowObject(m_pCRowset->pIRowset(),
m_rghRows[0]), S_OK, DB_S_NOROWSPECIFICCOLUMNS, E_NOINTERFACE)
if(!(ulVal & DBPROPVAL_OO_ROWOBJECT))
fSkip = TRUE;
if(hr == E_NOINTERFACE)
{
COMPARE(fSkip, TRUE);
TESTC_PROVIDER(!fSkip)
}
else
COMPARE(fSkip, FALSE);
//Make sure DBPROP_IRow prop is supported by the rowset.
COMPARE(GetProperty(DBPROP_IRow, DBPROPSET_ROWSET, (IUnknown*)
m_pCRowset->pIRowset(), &bValue), TRUE);
}
break;
//Get a Rowset by executing a command, and obtain a Row obj from it.
case TC_RowsetByCommand:
{
VARIANT_BOOL bValue;
TESTC_PROVIDER(VerifyInterface(g_pIOpenRowset,IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCC))
TESTC_(pIDBCC->CreateCommand(NULL, IID_ICommandText, (IUnknown**)
&pICT), S_OK)
TESTC(GetRowsetFromCommand(pICT, &pIRowset))
TESTC_(m_pCRowset->CreateRowset(pIRowset),S_OK);
TESTC_(m_pCRowset->GetNextRows(0, 1, &m_cRowsObtained, &m_rghRows),S_OK)
TEST3C_(hr = m_pCRowObj->CreateRowObject(m_pCRowset->pIRowset(),
m_rghRows[0]), S_OK, DB_S_NOROWSPECIFICCOLUMNS, E_NOINTERFACE)
if(!(ulVal & DBPROPVAL_OO_ROWOBJECT))
fSkip = TRUE;
if(hr == E_NOINTERFACE)
{
COMPARE(fSkip, TRUE);
TESTC_PROVIDER(!fSkip)
}
else
COMPARE(fSkip, FALSE);
//Make sure DBPROP_IRow prop is supported by the rowset.
COMPARE(GetProperty(DBPROP_IRow, DBPROPSET_ROWSET, (IUnknown*)
m_pCRowset->pIRowset(), &bValue), TRUE);
}
break;
//Get a Schema Rowset, and obtain a Row obj from it.
case TC_SchemaRowset:
{
TESTC_PROVIDER(VerifyInterface(g_pIOpenRowset,IID_IDBSchemaRowset,
SESSION_INTERFACE, (IUnknown**)&pIDBSR))
TESTC_(pIDBSR->GetRowset(NULL, DBSCHEMA_PROVIDER_TYPES, 0,
NULL, IID_IRowset, 0, NULL, (IUnknown**)&pIRowset), S_OK)
TESTC_(m_pCRowset->CreateRowset(pIRowset),S_OK);
TESTC_(m_pCRowset->GetNextRows(0, 1, &m_cRowsObtained, &m_rghRows),S_OK)
TEST3C_(hr = m_pCRowObj->CreateRowObject(m_pCRowset->pIRowset(),
m_rghRows[0]), S_OK, DB_S_NOROWSPECIFICCOLUMNS, E_NOINTERFACE)
TESTC_PROVIDER(hr != E_NOINTERFACE)
}
break;
//Get a Columns Rowset, and obtain a Row obj from it.
case TC_ColumnsRowset:
{
m_pCRowsetA = new CRowset();
TESTC(m_pCRowsetA!=NULL)
m_pCRowsetA->SetProperty(DBPROP_IColumnsRowset);
TESTC_PROVIDER(S_OK == m_pCRowsetA->CreateRowset())
TESTC(VerifyInterface(m_pCRowsetA->pIRowset(),IID_IColumnsRowset,
ROWSET_INTERFACE, (IUnknown**)&pIColRowset))
TESTC_(pIColRowset->GetColumnsRowset(NULL, 0, NULL, IID_IRowset,
0, NULL, (IUnknown**)&pIRowset), S_OK)
TESTC_(m_pCRowset->CreateRowset(pIRowset),S_OK);
TESTC_(m_pCRowset->GetNextRows(0, 1, &m_cRowsObtained, &m_rghRows),S_OK)
TEST3C_(hr = m_pCRowObj->CreateRowObject(m_pCRowset->pIRowset(),
m_rghRows[0]), S_OK, DB_S_NOROWSPECIFICCOLUMNS, E_NOINTERFACE)
TESTC_PROVIDER(hr != E_NOINTERFACE)
}
break;
//Get a Row obj by direct binding from Root Binder.
case TC_DirectBindOnRootBinder:
{
TESTC(GetRootBinder())
dbImplSess.pUnkOuter = NULL;
dbImplSess.pSession = NULL;
dbImplSess.piid = &iid;
TESTC_PROVIDER(m_pwszRowURL!=NULL)
TESTC_PROVIDER((ulVal & DBPROPVAL_OO_DIRECTBIND) == DBPROPVAL_OO_DIRECTBIND)
TESTC_(m_pIBindResource->Bind(NULL, m_pwszRowURL,
DBBINDURLFLAG_READ, DBGUID_ROW, IID_IRow, NULL, &dbImplSess,
NULL, (IUnknown**)&pIRow), S_OK)
TESTC((pIRow != NULL) && (dbImplSess.pSession != NULL))
TESTC(VerifyInterface(dbImplSess.pSession,IID_IOpenRowset,
SESSION_INTERFACE, (IUnknown**)&m_pImplSess))
TESTC_(m_pCRowObj->SetRowObject(pIRow),S_OK)
}
break;
//Get a Row obj by direct binding from Provider.
case TC_DirectBindOnProvider:
{
TESTC(GetRootBinder())
dbImplSess.pUnkOuter = NULL;
dbImplSess.pSession = NULL;
dbImplSess.piid = &iid;
TESTC_PROVIDER(m_pwszRowURL!=NULL)
TESTC_PROVIDER((ulVal & DBPROPVAL_OO_DIRECTBIND) == DBPROPVAL_OO_DIRECTBIND)
TESTC_(m_pIBindResource->Bind(NULL, m_pwszRowURL,
DBBINDURLFLAG_READ, DBGUID_SESSION, IID_IBindResource, NULL,
NULL, NULL, (IUnknown**)&pIBRProv), S_OK)
TESTC(pIBRProv!=NULL)
TESTC_(pIBRProv->Bind(NULL, m_pwszRowURL,
DBBINDURLFLAG_READ, DBGUID_ROW, IID_IRow, NULL, NULL,
NULL, (IUnknown**)&pIRow), S_OK)
TESTC(pIRow != NULL)
TESTC(VerifyInterface(pIBRProv,IID_IOpenRowset,
SESSION_INTERFACE, (IUnknown**)&m_pImplSess))
TESTC_(m_pCRowObj->SetRowObject(pIRow),S_OK)
}
break;
//Get a Row obj by calling GetSourceRow from a Stream obj.
case TC_GetSourceRow:
{
TESTC(GetRootBinder())
dbImplSess.pUnkOuter = NULL;
dbImplSess.pSession = NULL;
dbImplSess.piid = &iid;
TESTC_PROVIDER(m_pwszRowURL!=NULL)
TESTC_PROVIDER((ulVal & DBPROPVAL_OO_DIRECTBIND) == DBPROPVAL_OO_DIRECTBIND)
TESTC_(m_pIBindResource->Bind(NULL, m_pwszRowURL,
DBBINDURLFLAG_READ, DBGUID_STREAM, IID_IGetSourceRow, NULL,
&dbImplSess, NULL, (IUnknown**)&pIGSR), S_OK)
TESTC((pIGSR != NULL) && (dbImplSess.pSession != NULL))
TESTC(VerifyInterface(dbImplSess.pSession,IID_IOpenRowset,
SESSION_INTERFACE, (IUnknown**)&m_pImplSess))
TESTC_PROVIDER(pIGSR->GetSourceRow(IID_IRow, (IUnknown**)&pIRow) == S_OK)
TESTC(pIRow!=NULL)
TESTC_(m_pCRowObj->SetRowObject(pIRow),S_OK)
}
break;
//Get a Row obj from OpenRowset.
case TC_OpenRowsetDirect:
{
TESTC((g_pIOpenRowset!=NULL) && (m_pTable!=NULL))
dbid = m_pTable->GetTableID();
TEST3C_(hr = g_pIOpenRowset->OpenRowset(NULL, &dbid, NULL,
IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, DB_S_NOTSINGLETON,
E_NOINTERFACE)
if(!(ulVal & DBPROPVAL_OO_SINGLETON))
fSkip = TRUE;
if(hr == E_NOINTERFACE)
{
COMPARE(fSkip, TRUE);
TESTC_PROVIDER(!fSkip)
}
else
COMPARE(fSkip, FALSE);
TESTC(pIRow!=NULL)
TESTC_(m_pCRowObj->SetRowObject(pIRow), S_OK)
}
break;
//Get a Row obj directly by executing a command.
case TC_CommandDirect:
{
if(ulVal & DBPROPVAL_OO_SINGLETON)
bSingleton = TRUE;
TEST3C_(hr = m_pTable->ExecuteCommand(SELECT_ALLFROMTBL, IID_IRow,
NULL, NULL, NULL, NULL, EXECUTE_IFNOERROR, 0, NULL, NULL,
(IUnknown**)&pIRow, NULL), S_OK,
DB_S_NOTSINGLETON, E_NOINTERFACE)
if(!(ulVal & DBPROPVAL_OO_SINGLETON))
fSkip = TRUE;
if(hr == E_NOINTERFACE)
{
COMPARE(fSkip, TRUE);
TESTC_PROVIDER(!fSkip)
}
else
COMPARE(fSkip, FALSE);
TESTC(pIRow != NULL)
TESTC_(m_pCRowObj->SetRowObject(pIRow), S_OK)
}
break;
default:
ASSERT(!L"Unhandled Type...");
break;
};
CLEANUP:
SAFE_RELEASE(pICT);
SAFE_RELEASE(pIBRProv);
SAFE_RELEASE(pIGSR);
SAFE_RELEASE(pIRow);
SAFE_RELEASE(dbImplSess.pSession);
SAFE_RELEASE(pIColRowset);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIDBSR);
SAFE_RELEASE(pIDBCC);
TRETURN
} //Init
//----------------------------------------------------------------------
// CGetSession::Terminate
//
BOOL CGetSession::Terminate()
{
ReleaseAll();
return CSessionObject::Terminate();
} //Terminate
//----------------------------------------------------------------------
// CGetSession::ReleaseAll
//
BOOL CGetSession::ReleaseAll()
{
if(m_rghRows && m_pCRowset)
m_pCRowset->ReleaseRows(m_cRowsObtained, m_rghRows);
SAFE_FREE(m_rghRows);
SAFE_FREE(m_pwszRowURL);
SAFE_DELETE(m_pCRowObj);
SAFE_DELETE(m_pCRowset);
SAFE_DELETE(m_pCRowsetA);
SAFE_RELEASE(m_pIBindResource);
SAFE_RELEASE(m_pImplSess);
return TRUE;
} //ReleaseAll
//----------------------------------------------------------------------
// CGetSession::testIOpenRowset
// Perform some basic testing of IOpenRowset interface that cannot be
// done in DefTestInterface func.
//
BOOL CGetSession::testIOpenRowset(IOpenRowset* pIOpenRowset)
{
TBEGIN
HRESULT hr;
ULONG cPropSets = 0;
DBPROPSET* rgPropSets = NULL;
DBID* pTableID = NULL;
IOpenRowset* pIOR = NULL;
IRowsetInfo* pIRowsetInfo = NULL;
TESTC((pIOpenRowset!=NULL) && (m_pTable!=NULL))
pTableID = &(m_pTable->GetTableIDRef());
SetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
SetProperty(DBPROP_IRowsetIdentity, DBPROPSET_ROWSET, &cPropSets, &rgPropSets);
//Open a rowset with IRowsetInfo and test it.
TESTC_(pIOpenRowset->OpenRowset(NULL, pTableID, NULL, IID_IRowsetInfo,
cPropSets, rgPropSets, (IUnknown**)&pIRowsetInfo), S_OK)
TESTC(pIRowsetInfo!=NULL)
TEST2C_(hr=pIRowsetInfo->GetSpecification(IID_IOpenRowset, (IUnknown**)
&pIOR), S_OK, S_FALSE)
if(hr == S_OK)
TESTC(VerifyEqualInterface(pIOpenRowset, pIOR))
TESTC(GetProperty(DBPROP_CANHOLDROWS, DBPROPSET_ROWSET, pIRowsetInfo))
TESTC(GetProperty(DBPROP_IRowsetIdentity, DBPROPSET_ROWSET, pIRowsetInfo))
CLEANUP:
FreeProperties(&cPropSets, &rgPropSets);
SAFE_RELEASE(pIOR);
SAFE_RELEASE(pIRowsetInfo);
TRETURN
} //testIOpenRowset
//----------------------------------------------------------------------
// CGetSession::GetRowsetFromCommand
// Execute a select * from [table] command to get back a rowset.
//
BOOL CGetSession::GetRowsetFromCommand(
ICommandText* pICT,
IRowset** ppIRowset)
{
TBEGIN
TESTC((pICT!=NULL) && (ppIRowset!=NULL) && (m_pTable!=NULL))
*ppIRowset = NULL;
TESTC_(m_pTable->ExecuteCommand(SELECT_ALLFROMTBL, IID_IRowset,
NULL,NULL,NULL,NULL, EXECUTE_IFNOERROR, 0, NULL, NULL,
(IUnknown**)ppIRowset, (ICommand**)&pICT), S_OK)
TESTC(ppIRowset != NULL)
TESTC(*ppIRowset != NULL)
CLEANUP:
TRETURN
} //GetRowsetFromCommand
//----------------------------------------------------------------------
// CGetSession::VerifyGetSession
// Common testing function for all positive case variations.
//
BOOL CGetSession::VerifyGetSession(REFIID riid)
{
TBEGIN
IUnknown* pISessUnk = INVALID(IUnknown*);
TEST3C_(m_hr = m_pCRowObj->GetSession(riid, (IUnknown**)&pISessUnk),
S_OK, DB_E_NOSOURCEOBJECT, E_NOINTERFACE)
if(FAILED(m_hr))
TESTC(!pISessUnk)
else
TESTC(pISessUnk != NULL)
//Should not get E_NOINTERFACE when a mandatory interface was asked.
if(riid==IID_IOpenRowset || riid==IID_IGetDataSource ||
riid==IID_ISessionProperties || riid==IID_IUnknown)
TEST2C_(m_hr, S_OK, DB_E_NOSOURCEOBJECT)
if(E_NOINTERFACE == m_hr)
{
odtLog<<L"INFO: "<<GetInterfaceName(riid)<<L" is not supported on session.\n";
goto CLEANUP; //Passed.
}
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
{
CHECKW(m_hr, S_OK);
goto CLEANUP; //Passed.
}
else
TESTC_(m_hr, S_OK)
TESTC(DefaultInterfaceTesting(pISessUnk, SESSION_INTERFACE, riid))
if((IID_IOpenRowset==riid) && (!m_fBinder))
TESTC(testIOpenRowset((IOpenRowset*)pISessUnk))
//If the ROW object was obtained by going thru a Binder, then
//it's Session is stored in m_pImplSess, else in g_pIOpenRowset.
if(m_fBinder)
TESTC(VerifyEqualInterface(pISessUnk, m_pImplSess))
else
TESTC(VerifyEqualInterface(pISessUnk, g_pIOpenRowset))
CLEANUP:
SAFE_RELEASE(pISessUnk);
TRETURN
} //VerifyGetSession
//----------------------------------------------------------------------
// CGetSession::GetRootBinder
// Get the IBindResource interface on Root Binder, Set Init Props, and
// get a ROW URL.
//
BOOL CGetSession::GetRootBinder()
{
TBEGIN
ULONG cPropSets = 0;
DBPROPSET* rgPropSets = NULL;
IBindResource* pIBR = NULL;
IDBBinderProperties* pIDBBProp = NULL;
pIBR = GetModInfo()->GetRootBinder();
if(!pIBR)
return FALSE;
if(!VerifyInterface(pIBR, IID_IBindResource,
BINDER_INTERFACE,(IUnknown**)&m_pIBindResource))
return FALSE;
if(!VerifyInterface(m_pIBindResource, IID_IDBBinderProperties,
BINDER_INTERFACE,(IUnknown**)&pIDBBProp))
return FALSE;
TESTC(GetInitProps(&cPropSets, &rgPropSets))
TESTC_(pIDBBProp->SetProperties(cPropSets, rgPropSets), S_OK)
//If an INI file exists and there is a [URL] section in it, get the
//ROW URL from there, otherwise look for it in CModInfo.
if(GetModInfo()->GetParseObject()->GetURL(ROW_INTERFACE))
m_pwszRowURL = wcsDuplicate(GetModInfo()->GetParseObject()->GetURL(ROW_INTERFACE));
else if(GetModInfo()->GetRootURL())
m_pwszRowURL = wcsDuplicate(GetModInfo()->GetRootURL());
if(!m_pwszRowURL)
odtLog<<L"WARNING: Could not get a ROW URL. Some Test Cases won't run.\n;";
CLEANUP:
FreeProperties(&cPropSets, &rgPropSets);
SAFE_RELEASE(pIDBBProp);
TRETURN
} //GetRootBinder
//*-----------------------------------------------------------------------
// Test Case Section
//*-----------------------------------------------------------------------
// {{ TCW_TEST_CASE_MAP(TCRowsetByOpenRowset)
//*-----------------------------------------------------------------------
// @class GetSession is tested on Row objects obtained from a Rowset which was opened using IOpenRowset
//
class TCRowsetByOpenRowset : public CGetSession {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCRowsetByOpenRowset,CGetSession);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember IID_IUnknown
int Variation_1();
// @cmember IID_IOpenRowset
int Variation_2();
// @cmember IID_IGetDataSource
int Variation_3();
// @cmember IID_ISessionProperties
int Variation_4();
// @cmember IID_IDBCreateCommand
int Variation_5();
// @cmember IID_IDBSchemaRowset
int Variation_6();
// @cmember ALL Optional Interfaces
int Variation_7();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCRowsetByOpenRowset)
#define THE_CLASS TCRowsetByOpenRowset
BEG_TEST_CASE(TCRowsetByOpenRowset, CGetSession, L"GetSession is tested on Row objects obtained from a Rowset which was opened using IOpenRowset")
TEST_VARIATION(1, L"IID_IUnknown")
TEST_VARIATION(2, L"IID_IOpenRowset")
TEST_VARIATION(3, L"IID_IGetDataSource")
TEST_VARIATION(4, L"IID_ISessionProperties")
TEST_VARIATION(5, L"IID_IDBCreateCommand")
TEST_VARIATION(6, L"IID_IDBSchemaRowset")
TEST_VARIATION(7, L"ALL Optional Interfaces")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCRowsetByOpenRowset_Boundary)
//*-----------------------------------------------------------------------
// @class Boundary cases.
//
class TCRowsetByOpenRowset_Boundary : public CGetSession {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCRowsetByOpenRowset_Boundary,CGetSession);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG
int Variation_1();
// @cmember E_INVALIDARG or E_NOINTERFACE
int Variation_2();
// @cmember E_NOINTERFACE - IID_NULL
int Variation_3();
// @cmember E_NOINTERFACE - IID_IDBCreateSession
int Variation_4();
// @cmember E_NOINTERFACE - IID_ICommandText
int Variation_5();
// @cmember E_NOINTERFACE - IID_IRowsetInfo
int Variation_6();
// @cmember E_NOINTERFACE - IID_IRow
int Variation_7();
// @cmember E_NOINTERFACE - IID_IGetSourceRow
int Variation_8();
// @cmember E_NOINTERFACE - IID_IDBBinderProperties
int Variation_9();
// @cmember E_NOINTERFACE - IID_IRegisterProvider
int Variation_10();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCRowsetByOpenRowset_Boundary)
#define THE_CLASS TCRowsetByOpenRowset_Boundary
BEG_TEST_CASE(TCRowsetByOpenRowset_Boundary, CGetSession, L"Boundary cases.")
TEST_VARIATION(1, L"E_INVALIDARG")
TEST_VARIATION(2, L"E_INVALIDARG or E_NOINTERFACE")
TEST_VARIATION(3, L"E_NOINTERFACE - IID_NULL")
TEST_VARIATION(4, L"E_NOINTERFACE - IID_IDBCreateSession")
TEST_VARIATION(5, L"E_NOINTERFACE - IID_ICommandText")
TEST_VARIATION(6, L"E_NOINTERFACE - IID_IRowsetInfo")
TEST_VARIATION(7, L"E_NOINTERFACE - IID_IRow")
TEST_VARIATION(8, L"E_NOINTERFACE - IID_IGetSourceRow")
TEST_VARIATION(9, L"E_NOINTERFACE - IID_IDBBinderProperties")
TEST_VARIATION(10, L"E_NOINTERFACE - IID_IRegisterProvider")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCMiscellaneous)
//*-----------------------------------------------------------------------
// @class Miscellaneous variations
//
class TCMiscellaneous : public CGetSession{
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCMiscellaneous,CGetSession);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Aggregate a session and get a row.
int Variation_1();
// @cmember Release parent objects before calling GetSession.
int Variation_2();
// @cmember Delete an HROW and call GetSession.
int Variation_3();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCMiscellaneous)
#define THE_CLASS TCMiscellaneous
BEG_TEST_CASE(TCMiscellaneous, CGetSession, L"Miscellaneous variations")
TEST_VARIATION(1, L"Aggregate a session and get a row.")
TEST_VARIATION(2, L"Release parent objects before calling GetSession.")
TEST_VARIATION(3, L"Delete an HROW and call GetSession.")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCRowZombie)
//*-----------------------------------------------------------------------
// @class Zombie state tests
//
class TCRowZombie : public TCTransactions {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCRowZombie,TCTransactions);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Abort with fRetaining=FALSE
int Variation_1();
// @cmember Abort with fRetaining=TRUE
int Variation_2();
// @cmember Commit with fRetaining=FALSE
int Variation_3();
// @cmember Commit with fRetaining=TRUE
int Variation_4();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCRowZombie)
#define THE_CLASS TCRowZombie
BEG_TEST_CASE(TCRowZombie, TCTransactions, L"Zombie state tests")
TEST_VARIATION(1, L"Abort with fRetaining=FALSE")
TEST_VARIATION(2, L"Abort with fRetaining=TRUE")
TEST_VARIATION(3, L"Commit with fRetaining=FALSE")
TEST_VARIATION(4, L"Commit with fRetaining=TRUE")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
////////////////////////////////////////////////////////////////////////
// Copying Test Cases to make duplicate ones.
//
////////////////////////////////////////////////////////////////////////
#define COPY_TEST_CASE(theClass, baseClass) \
class theClass : public baseClass \
{ \
public: \
static const WCHAR m_wszTestCaseName[]; \
DECLARE_TEST_CASE_FUNCS(theClass, baseClass); \
}; \
const WCHAR theClass::m_wszTestCaseName[] = { L#theClass }; \
#define TEST_CASE_WITH_PARAM(iCase, theClass, param) \
case iCase: \
pCTestCase = new theClass(NULL); \
((theClass*)pCTestCase)->SetTestCaseParam(param); \
pCTestCase->SetOwningMod(iCase-1, pCThisTestModule); \
return pCTestCase;
//2
COPY_TEST_CASE(TCRowsetByCommand, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCRowsetByCommand_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCRowsetByCommand_Zombie, TCRowZombie)
//3
COPY_TEST_CASE(TCSchemaRowset, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCSchemaRowset_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCSchemaRowset_Zombie, TCRowZombie)
//4
COPY_TEST_CASE(TCColumnsRowset, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCColumnsRowset_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCColumnsRowset_Zombie, TCRowZombie)
//5
COPY_TEST_CASE(TCDirectBindOnRootBinder, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCDirectBindOnRootBinder_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCDirectBindOnRootBinder_Zombie, TCRowZombie)
//6
COPY_TEST_CASE(TCDirectBindOnProvider, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCDirectBindOnProvider_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCDirectBindOnProvider_Zombie, TCRowZombie)
//7
COPY_TEST_CASE(TCGetSourceRow, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCGetSourceRow_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCGetSourceRow_Zombie, TCRowZombie)
//8
COPY_TEST_CASE(TCOpenRowsetDirect, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCOpenRowsetDirect_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCOpenRowsetDirect_Zombie, TCRowZombie)
//9
COPY_TEST_CASE(TCCommandDirect, TCRowsetByOpenRowset)
COPY_TEST_CASE(TCCommandDirect_Boundary, TCRowsetByOpenRowset_Boundary)
COPY_TEST_CASE(TCCommandDirect_Zombie, TCRowZombie)
//NOTE: The #ifdef block below is only for test wizard. TestWizard has too many
//strict rules in the parsing code and requires a 1:1 correspondence between
//testcases and the map. What the #else section is doing is basically "reusing"
//existing testcases by just passing in a parameter which changes the behvior.
//So we make LTM think there are 15 cases in here with different names, but in
//reality we only have to maintain code for the unique cases.
#if 0
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(4, ThisModule, gwszModuleDescrip)
TEST_CASE(1, TCRowsetByOpenRowset)
TEST_CASE(2, TCRowsetByOpenRowset_Boundary)
TEST_CASE(3, TCMiscellaneous)
TEST_CASE(4, TCRowZombie)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
#else
TEST_MODULE(20, ThisModule, gwszModuleDescrip)
//1
TEST_CASE(1, TCRowsetByOpenRowset)
TEST_CASE(2, TCRowsetByOpenRowset_Boundary)
//2
TEST_CASE_WITH_PARAM(3, TCRowsetByCommand, TC_RowsetByCommand)
TEST_CASE_WITH_PARAM(4, TCRowsetByCommand_Boundary, TC_RowsetByCommand)
//3
TEST_CASE_WITH_PARAM(5, TCSchemaRowset, TC_SchemaRowset)
TEST_CASE_WITH_PARAM(6, TCSchemaRowset_Boundary, TC_SchemaRowset)
//4
TEST_CASE_WITH_PARAM(7, TCColumnsRowset, TC_ColumnsRowset)
TEST_CASE_WITH_PARAM(8, TCColumnsRowset_Boundary, TC_ColumnsRowset)
//5
TEST_CASE_WITH_PARAM(9, TCDirectBindOnRootBinder, TC_DirectBindOnRootBinder)
TEST_CASE_WITH_PARAM(10, TCDirectBindOnRootBinder_Boundary, TC_DirectBindOnRootBinder)
//6
TEST_CASE_WITH_PARAM(11, TCDirectBindOnProvider, TC_DirectBindOnProvider)
TEST_CASE_WITH_PARAM(12, TCDirectBindOnProvider_Boundary, TC_DirectBindOnProvider)
//7
TEST_CASE_WITH_PARAM(13, TCGetSourceRow, TC_GetSourceRow)
TEST_CASE_WITH_PARAM(14, TCGetSourceRow_Boundary, TC_GetSourceRow)
//8
TEST_CASE_WITH_PARAM(15, TCOpenRowsetDirect, TC_OpenRowsetDirect)
TEST_CASE_WITH_PARAM(16, TCOpenRowsetDirect_Boundary, TC_OpenRowsetDirect)
//9
TEST_CASE_WITH_PARAM(17, TCCommandDirect, TC_CommandDirect)
TEST_CASE_WITH_PARAM(18, TCCommandDirect_Boundary, TC_CommandDirect)
TEST_CASE(19, TCMiscellaneous)
TEST_CASE(20, TCRowZombie)
END_TEST_MODULE()
#endif
// {{ TCW_TC_PROTOTYPE(TCRowsetByOpenRowset)
//*-----------------------------------------------------------------------
//| Test Case: TCRowsetByOpenRowset - GetSession is tested on Row objects obtained from a Rowset which was opened using IOpenRowset
//| Created: 9/29/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCRowsetByOpenRowset::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
return CGetSession::Init(m_eTestCase);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc IID_IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_1()
{
return VerifyGetSession(IID_IUnknown);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc IID_IOpenRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_2()
{
return VerifyGetSession(IID_IOpenRowset);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc IID_IGetDataSource
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_3()
{
return VerifyGetSession(IID_IGetDataSource);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc IID_ISessionProperties
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_4()
{
return VerifyGetSession(IID_ISessionProperties);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc IID_IDBCreateCommand
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_5()
{
return VerifyGetSession(IID_IDBCreateCommand);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc IID_IDBSchemaRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_6()
{
return VerifyGetSession(IID_IDBSchemaRowset);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc ALL Optional Interfaces
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset::Variation_7()
{
TBEGIN
ULONG i = 0;
ULONG cInterfaces = 0;
INTERFACEMAP* rgInterfaces = NULL;
// Obtain the SESSION interface array
TESTC(GetInterfaceArray(SESSION_INTERFACE, &cInterfaces, &rgInterfaces));
for(i=0; i < cInterfaces; i++)
{
//If interface is optional
if(!rgInterfaces[i].fMandatory)
TESTC(VerifyGetSession(*(rgInterfaces[i].pIID)));
}
CLEANUP:
if(TESTB==TEST_FAIL)
odtLog<<L"INFO: Failed on interface "<<GetInterfaceName(*(rgInterfaces[i].pIID))<<".\n";
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCRowsetByOpenRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CGetSession::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCRowsetByOpenRowset_Boundary)
//*-----------------------------------------------------------------------
//| Test Case: TCRowsetByOpenRowset_Boundary - Boundary cases.
//| Created: 10/5/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCRowsetByOpenRowset_Boundary::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
return CGetSession::Init(m_eTestCase);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_1()
{
TBEGIN
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IOpenRowset, NULL),
E_INVALIDARG, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_INVALIDARG);
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG or E_NOINTERFACE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_2()
{
TBEGIN
TEST3C_(m_hr = m_pCRowObj->GetSession(IID_IDBCreateSession, NULL),
E_INVALIDARG, E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_INVALIDARG);
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_3()
{
TBEGIN
IUnknown* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_NULL, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IDBCreateSession
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_4()
{
TBEGIN
IDBCreateSession* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IDBCreateSession, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_ICommandText
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_5()
{
TBEGIN
ICommandText* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_ICommandText, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IRowsetInfo
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_6()
{
TBEGIN
IRowsetInfo* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IRowsetInfo, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IRow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_7()
{
TBEGIN
IRow* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IRow, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IGetSourceRow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_8()
{
TBEGIN
IGetSourceRow* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IGetSourceRow, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IDBBinderProperties
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_9()
{
TBEGIN
IDBBinderProperties* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IDBBinderProperties, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc E_NOINTERFACE - IID_IRegisterProvider
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowsetByOpenRowset_Boundary::Variation_10()
{
TBEGIN
IRegisterProvider* pIUnk = NULL;
TEST2C_(m_hr = m_pCRowObj->GetSession(IID_IRegisterProvider, (IUnknown**)&pIUnk),
E_NOINTERFACE, DB_E_NOSOURCEOBJECT)
if((DB_E_NOSOURCEOBJECT == m_hr) && m_fWarning)
CHECKW(m_hr, E_NOINTERFACE);
TESTC(!pIUnk)
CLEANUP:
SAFE_RELEASE(pIUnk);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCRowsetByOpenRowset_Boundary::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CGetSession::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCMiscellaneous)
//*-----------------------------------------------------------------------
//| Test Case: TCMiscellaneous - Miscellaneous variations
//| Created: 5/18/1999
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCMiscellaneous::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CSessionObject::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Aggregate a session and get a row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCMiscellaneous::Variation_1()
{
TBEGIN
HRESULT hr;
DBCOUNTITEM cRowsObtained=0;
HROW* rghRows=NULL;
IDBCreateSession* pIDBCS=NULL;
IOpenRowset* pIOR=NULL;
IGetRow* pIGR=NULL;
IRowset* pIRowset=NULL;
IGetSession* pIGS=NULL;
IUnknown* pISessUnk=NULL;
IUnknown* pIUnkInner = NULL;
IRow* pIRow = NULL;
CAggregate Aggregate;
//Create a new aggregated session.
TEST2C_(hr = CreateNewSession(NULL, IID_IUnknown,
(IUnknown**)&pIUnkInner, &Aggregate), S_OK, DB_E_NOAGGREGATION);
Aggregate.SetUnkInner(pIUnkInner);
TESTC_PROVIDER(hr == S_OK);
TESTC(VerifyInterface(pIUnkInner,IID_IOpenRowset,
SESSION_INTERFACE, (IUnknown**)&pIOR))
//Open a rowset on this aggregated session and get a row
//object from it.
TEST2C_(hr = pIOR->OpenRowset(NULL, &(g_pTable->GetTableID()),
NULL, IID_IGetRow, 0, NULL, (IUnknown**)&pIGR), S_OK, E_NOINTERFACE)
if(hr == S_OK)
{
TESTC(VerifyInterface(pIGR,IID_IRowset,
ROWSET_INTERFACE, (IUnknown**)&pIRowset))
TESTC_(hr = pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained,
&rghRows), S_OK)
TESTC_(hr = pIGR->GetRowFromHROW(NULL, rghRows[0],
IID_IGetSession, (IUnknown**)&pIGS), S_OK)
}
else
{
TEST2C_(hr = pIOR->OpenRowset(NULL, &(g_pTable->GetTableID()),
NULL, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, E_NOINTERFACE)
TESTC_PROVIDER(hr == S_OK);
TESTC(VerifyInterface(pIRow,IID_IGetSession,
ROW_INTERFACE, (IUnknown**)&pIGS))
}
//Call GetSession and verify the correct IUnknown is returned.
TEST2C_(hr = pIGS->GetSession(IID_IUnknown,
(IUnknown**)&pISessUnk), S_OK, DB_E_NOSOURCEOBJECT)
TESTC_PROVIDER(hr == S_OK)
TESTC(VerifyEqualInterface(pISessUnk, (IUnknown*)&Aggregate))
CLEANUP:
if(pIRowset && rghRows)
pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL,NULL,NULL);
SAFE_FREE(rghRows);
SAFE_RELEASE(pIUnkInner);
SAFE_RELEASE(pISessUnk);
SAFE_RELEASE(pIGS);
SAFE_RELEASE(pIRow);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIGR);
SAFE_RELEASE(pIOR);
SAFE_RELEASE(pIDBCS);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Release parent objects before calling GetSession.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCMiscellaneous::Variation_2()
{
TBEGIN
HRESULT hr;
DBCOUNTITEM cRowsObtained=0;
HROW* rghRows=NULL;
IDBCreateSession* pIDBCS=NULL;
IOpenRowset* pIOR=NULL;
IGetRow* pIGR=NULL;
IRowset* pIRowset=NULL;
IGetSession* pIGS=NULL;
IUnknown* pISessUnk=NULL;
IRow* pIRow = NULL;
//Create a new dso and session.
TESTC_(CreateNewDSO(NULL, IID_IDBCreateSession,
(IUnknown**)&pIDBCS), S_OK)
TESTC_(hr = pIDBCS->CreateSession(NULL, IID_IOpenRowset,
(IUnknown**)&pIOR), S_OK)
//Open a rowset and get a row object from first row.
TEST2C_(hr = pIOR->OpenRowset(NULL, &(g_pTable->GetTableID()),
NULL, IID_IGetRow, 0, NULL, (IUnknown**)&pIGR), S_OK, E_NOINTERFACE)
if(hr == S_OK)
{
TESTC(VerifyInterface(pIGR,IID_IRowset,
ROWSET_INTERFACE, (IUnknown**)&pIRowset))
TESTC_(hr = pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained,
&rghRows), S_OK)
TESTC_(hr = pIGR->GetRowFromHROW(NULL, rghRows[0],
IID_IGetSession, (IUnknown**)&pIGS), S_OK)
}
else
{
TEST2C_(hr = pIOR->OpenRowset(NULL, &(g_pTable->GetTableID()),
NULL, IID_IRow, 0, NULL, (IUnknown**)&pIRow), S_OK, E_NOINTERFACE)
TESTC_PROVIDER(hr == S_OK);
TESTC(VerifyInterface(pIRow,IID_IGetSession,
ROW_INTERFACE, (IUnknown**)&pIGS))
}
//Call GetSession and verify.
TEST2C_(hr = pIGS->GetSession(IID_IUnknown,
(IUnknown**)&pISessUnk), S_OK, DB_E_NOSOURCEOBJECT)
TESTC_PROVIDER(hr == S_OK)
TESTC(VerifyEqualInterface(pISessUnk, pIOR))
//Release all parent objects.
if(pIRowset && rghRows)
pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL,NULL,NULL);
SAFE_FREE(rghRows);
SAFE_RELEASE(pISessUnk);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIGR);
SAFE_RELEASE(pIOR);
SAFE_RELEASE(pIDBCS);
//Verify that GetSession still works.
TESTC_(hr = pIGS->GetSession(IID_IOpenRowset,
(IUnknown**)&pIOR), S_OK)
TESTC(pIOR!=NULL)
TESTC(DefTestInterface((IOpenRowset*)pIOR))
CLEANUP:
if(pIRowset && rghRows)
pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL,NULL,NULL);
SAFE_FREE(rghRows);
SAFE_RELEASE(pISessUnk);
SAFE_RELEASE(pIGS);
SAFE_RELEASE(pIRow);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIGR);
SAFE_RELEASE(pIOR);
SAFE_RELEASE(pIDBCS);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Delete an HROW and call GetSession.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCMiscellaneous::Variation_3()
{
TBEGIN
HRESULT hr;
DBCOUNTITEM cRowsObtained=0;
ULONG cPropSets=0;
DBPROPSET* rgPropSets=NULL;
HROW* rghRows=NULL;
IDBCreateSession* pIDBCS=NULL;
IOpenRowset* pIOR=NULL;
IGetRow* pIGR=NULL;
IRowset* pIRowset=NULL;
IRowsetChange* pIRowsetChange=NULL;
IGetSession* pIGS=NULL;
IUnknown* pISessUnk=NULL;
//Create a new dso and session.
TESTC_(CreateNewDSO(NULL, IID_IDBCreateSession,
(IUnknown**)&pIDBCS), S_OK)
TESTC_(hr = pIDBCS->CreateSession(NULL, IID_IOpenRowset,
(IUnknown**)&pIOR), S_OK)
//Set props to get an updateable rowset.
SetProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET,
&cPropSets, &rgPropSets) ;
SetProperty(DBPROP_UPDATABILITY, DBPROPSET_ROWSET,
&cPropSets, &rgPropSets, (void*)DBPROPVAL_UP_DELETE, DBTYPE_I4) ;
//Get an updateable rowset, and get a row object from
//it's first row.
TEST2C_(hr = pIOR->OpenRowset(NULL, &(g_pTable->GetTableID()),
NULL, IID_IRowsetChange, cPropSets, rgPropSets, (IUnknown**)&pIRowsetChange),
S_OK, DB_E_ERRORSOCCURRED)
TESTC_PROVIDER(hr == S_OK);
TESTC_PROVIDER(VerifyInterface(pIRowsetChange,IID_IGetRow,
ROWSET_INTERFACE, (IUnknown**)&pIGR))
TESTC(VerifyInterface(pIGR,IID_IRowset,
ROWSET_INTERFACE, (IUnknown**)&pIRowset))
TESTC_(hr = pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained,
&rghRows), S_OK)
TESTC_(hr = pIGR->GetRowFromHROW(NULL, rghRows[0],
IID_IGetSession, (IUnknown**)&pIGS), S_OK)
//Call Getsession and verify.
TEST2C_(hr = pIGS->GetSession(IID_IUnknown,
(IUnknown**)&pISessUnk), S_OK, DB_E_NOSOURCEOBJECT)
TESTC_PROVIDER(hr == S_OK)
TESTC(VerifyEqualInterface(pISessUnk, pIOR))
SAFE_RELEASE(pISessUnk);
//Delete the row.
TESTC_(hr=pIRowsetChange->DeleteRows(NULL, 1, rghRows, NULL), S_OK)
SAFE_FREE(rghRows);
//Call GetSession again and verify.
TESTC_(hr = pIGS->GetSession(IID_IUnknown,
(IUnknown**)&pISessUnk), S_OK)
TESTC(pISessUnk!=NULL)
TESTC(VerifyEqualInterface(pISessUnk, pIOR))
CLEANUP:
FreeProperties(&cPropSets, &rgPropSets);
if(pIRowset && rghRows)
pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL,NULL,NULL);
SAFE_FREE(rghRows);
SAFE_RELEASE(pISessUnk);
SAFE_RELEASE(pIGS);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIRowsetChange);
SAFE_RELEASE(pIGR);
SAFE_RELEASE(pIOR);
SAFE_RELEASE(pIDBCS);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCMiscellaneous::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CSessionObject::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCRowZombie)
//*-----------------------------------------------------------------------
//| Test Case: TCRowZombie - Zombie state tests
//| Created: 10/5/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCRowZombie::Init()
{
// Check to see if Transactions are usable
if(!IsUsableInterface(SESSION_INTERFACE, IID_ITransactionLocal))
return TEST_SKIPPED;
// Initialize to a invalid pointer
m_pITransactionLocal = INVALID(ITransactionLocal*);
// {{ TCW_INIT_BASECLASS_CHECK
if(TCTransactions::Init())
// }}
{
//This is a mandatory interface, it should always succeed
if(!RegisterInterface(ROW_INTERFACE, IID_IGetSession, 0, NULL))
return TEST_SKIPPED;
else
return TRUE;
}
// Check to see if ITransaction is supported
if(!m_pITransactionLocal)
return TEST_SKIPPED;
// Clear the bad pointer value
if(m_pITransactionLocal == INVALID(ITransactionLocal*))
m_pITransactionLocal = NULL;
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining=FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowZombie::Variation_1()
{
return TestTxnRow(FALSE, FALSE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining=TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowZombie::Variation_2()
{
return TestTxnRow(FALSE, TRUE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining=FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowZombie::Variation_3()
{
return TestTxnRow(TRUE, FALSE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining=TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCRowZombie::Variation_4()
{
return TestTxnRow(TRUE, TRUE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCRowZombie::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCTransactions::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
Reference in New Issue View Git Blame Copy Permalink