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/irowpos/irowpos.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

5692 lines
162 KiB
C++
Raw Blame History

//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright (C) 1995-2000 Microsoft Corporation
//
// @doc
//
// @module IRowPos.cpp | Tests for the IRowPosition and IRowPositionChange interfaces.
//
/////////////////////////////////////////////////////////////////////////
// Includes
//
/////////////////////////////////////////////////////////////////////////
#include "modstandard.hpp"
#include "IRowPos.h" //The Header file.
#include "ExtraLib.h" //Usefull functions that we use.
#include "olectl.h" //CONNECT_E_NOCONNECT
/////////////////////////////////////////////////////////////////////////
// Defines
//
/////////////////////////////////////////////////////////////////////////
#define MAX_LISTENERS 3
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0x0fd29ae1, 0xe1f4, 0x11d0, { 0x94, 0x46, 0x00, 0xc0, 0x4f, 0xd7, 0x05, 0xe9 }};
DECLARE_MODULE_NAME("IRowPosition");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("IRowPosition holds the current row on a Rowset");
DECLARE_MODULE_VERSION(795921705);
// 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)
{
return CommonModuleInit(pThisTestModule, IID_IRowset, FIVE_ROWS);
}
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
return CommonModuleTerminate(pThisTestModule);
}
////////////////////////////////////////////////////////////////////////////
// TCRowPosition
//
////////////////////////////////////////////////////////////////////////////
class TCRowPosition : public CRowset
{
public:
//Constructors
TCRowPosition(WCHAR* pwszTestCaseName = INVALID(WCHAR*));
virtual ~TCRowPosition();
//methods
virtual BOOL Init();
virtual BOOL Terminate();
//helpers
static HRESULT CreateRowPosition(IUnknown* pIRowset, IRowPosition** ppIRowPosition = NULL);
static HRESULT Initialize(IRowPosition* pIRowPosition, IUnknown* pIRowset);
static HRESULT ClearRowPosition(IRowPosition* pIRowPosition);
static HRESULT SetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags);
static HRESULT GetRowPosition(IRowPosition* pIRowPosition, HCHAPTER* phChapter, HROW* phRow, DBPOSITIONFLAGS* pdwPosFlags);
static HRESULT GetRowset(IRowPosition* pIRowPosition, REFIID riid, IUnknown** ppIRowset);
virtual BOOL VerifyGetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags);
virtual BOOL VerifySetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags);
//Connection Points
virtual IConnectionPoint* const pICP();
virtual IConnectionPointContainer* const pICPC();
virtual IEnumConnectionPoints* const pIEnumCP();
virtual IRowPosition* const pIRowPos();
//Notifications
virtual BOOL VerifyDiffCookies(ULONG cCookies, DWORD* rgCookies) const;
virtual BOOL AdviseAll(ULONG* rgCookies, IRowPosition* pIRowPosition = NULL);
virtual BOOL UnadviseAll(ULONG* rgCookies, IRowPosition* pIRowPosition = NULL);
virtual BOOL RestartListeners();
virtual BOOL ResetTimesNotified();
virtual BOOL VerifyTimesNotified(ULONG cTimes, DBREASON eReason = DBREASON_ALL, DBEVENTPHASE ePhase = DBEVENTPHASE_ALL);
virtual BOOL VerifyFailedTodo(DBREASON eReason, DBEVENTPHASE ePhase);
//Enumerations
virtual BOOL VerifyConnectData(ULONG cConnections, CONNECTDATA* rgConnectData, ULONG cCookies, IUnknown** rgpListeners, DWORD* rgCookies);
virtual BOOL FreeConnectData(ULONG cConnections, CONNECTDATA* rgConnectData);
//Thread Functions
static ULONG WINAPI Thread_CreateRowPosition(LPVOID pv);
static ULONG WINAPI Thread_Initialize(LPVOID pv);
static ULONG WINAPI Thread_GetRowset(LPVOID pv);
static ULONG WINAPI Thread_GetRowPosition(LPVOID pv);
static ULONG WINAPI Thread_ClearSetGetCombo(LPVOID pv);
public:
//data
DBCOUNTITEM m_ulTotalRows;
protected:
//data
IConnectionPoint* m_pIConnectionPoint;
IConnectionPointContainer* m_pIConnectionPointContainer;
IEnumConnectionPoints* m_pIEnumConnectionPoints;
IRowPosition* m_pIRowPosition;
//Listeners
ULONG m_cListeners;
CListener* m_rgpListeners[MAX_LISTENERS];
};
TCRowPosition::TCRowPosition(WCHAR* pwszTestCaseName) : CRowset(pwszTestCaseName)
{
//Connection
m_pIConnectionPoint = NULL;
m_pIConnectionPointContainer = NULL;
m_pIEnumConnectionPoints = NULL;
m_pIRowPosition = NULL;
m_ulTotalRows = 0; //the number of rows that we use right now.
m_cListeners = 0;
}
TCRowPosition::~TCRowPosition()
{
}
BOOL TCRowPosition::Init()
{
TBEGIN
ULONG i=0;
//Initialize inherited object
TESTC(CRowset::Init());
//Create Rowset object
TESTC_(CreateRowset(DBPROP_CANHOLDROWS),S_OK);
m_ulTotalRows = GetTotalRows();
//Create RowPosition object
TESTC_(CreateRowPosition(pIRowset(), &m_pIRowPosition),S_OK);
//Obtain the connection point container
TESTC_((QI(m_pIRowPosition,IID_IConnectionPointContainer,(void**)&m_pIConnectionPointContainer)),S_OK);
//Obtain the IRowsetNotify connection point
TESTC_(m_pIConnectionPointContainer->FindConnectionPoint(IID_IRowPositionChange, &m_pIConnectionPoint),S_OK);
//Obtain the IEnumConnectionPoints
TESTC_(m_pIConnectionPointContainer->EnumConnectionPoints(&m_pIEnumConnectionPoints),S_OK);
//Create Listeners
m_cListeners = MAX_LISTENERS;
for(i=0; i<m_cListeners; i++)
{
m_rgpListeners[i] = new CListener(IID_IRowPositionChange, m_pIRowPosition);
SAFE_ADDREF(m_rgpListeners[i]);
}
CLEANUP:
TRETURN
}
BOOL TCRowPosition::Terminate()
{
//Remove Listeners
for(ULONG i=0; i<m_cListeners; i++)
{
SAFE_RELEASE(m_rgpListeners[i]);
}
SAFE_RELEASE(m_pIConnectionPoint);
SAFE_RELEASE(m_pIConnectionPointContainer);
SAFE_RELEASE(m_pIEnumConnectionPoints);
//Release all interfaces
SAFE_RELEASE(m_pIRowPosition);
return CRowset::Terminate();
}
HRESULT TCRowPosition::CreateRowPosition(IUnknown* pIRowset, IRowPosition** ppIRowPosition)
{
HRESULT hr = E_FAIL;
IRowPosition* pIRowPosition = NULL;
//CreateInstance of IRowPosition
hr = CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPosition, (void**)&pIRowPosition);
if(SUCCEEDED(hr))
{
TESTC(pIRowPosition != NULL);
}
else
{
TESTC(pIRowPosition == NULL);
}
//Initialize
QTESTC_(hr = Initialize(pIRowPosition, pIRowset),S_OK);
CLEANUP:
if(ppIRowPosition)
*ppIRowPosition = pIRowPosition;
else
SAFE_RELEASE(pIRowPosition);
return hr;
}
HRESULT TCRowPosition::Initialize(IRowPosition* pIRowPosition, IUnknown* pIRowset)
{
TBEGIN
ASSERT(pIRowPosition);
return pIRowPosition->Initialize(pIRowset);
}
HRESULT TCRowPosition::ClearRowPosition(IRowPosition* pIRowPosition)
{
TBEGIN
ASSERT(pIRowPosition);
return pIRowPosition->ClearRowPosition();
}
HRESULT TCRowPosition::GetRowset(IRowPosition* pIRowPosition, REFIID riid, IUnknown** ppIRowset)
{
TBEGIN
HRESULT hr = S_OK;
ASSERT(pIRowPosition);
hr = pIRowPosition->GetRowset(riid, ppIRowset);
if(ppIRowset)
{
if(SUCCEEDED(hr))
{
TESTC(*ppIRowset != NULL);
}
else
{
TESTC(*ppIRowset == NULL);
}
}
CLEANUP:
return hr;
}
HRESULT TCRowPosition::SetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags)
{
TBEGIN
ASSERT(pIRowPosition);
HRESULT hr = E_FAIL;
IRowset* pIRowset = NULL;
//SetRowPosition
hr = pIRowPosition->SetRowPosition(hChapter, hRow, dwPosFlags);
//Need to release the extra row handle reference (if successful)
if(SUCCEEDED(hr) && hRow != DB_NULL_HROW)
{
//GetRowset
TESTC_(GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset),S_OK);
TESTC_(pIRowset->ReleaseRows(1, &hRow, NULL, NULL, NULL),S_OK);
}
CLEANUP:
SAFE_RELEASE(pIRowset);
return hr;
}
HRESULT TCRowPosition::GetRowPosition(IRowPosition* pIRowPosition, HCHAPTER* phChapter, HROW* phRow, DBPOSITIONFLAGS* pdwPosFlags)
{
TBEGIN
ASSERT(pIRowPosition);
HRESULT hr = E_FAIL;
IRowset* pIRowset = NULL;
//GetRowPosition
hr = pIRowPosition->GetRowPosition(phChapter, phRow, pdwPosFlags);
//Need to release the extra row handle reference (if successful)
if(SUCCEEDED(hr) && phRow && *phRow != DB_NULL_HROW)
{
//GetRowset
TESTC_(GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset),S_OK);
TESTC_(pIRowset->ReleaseRows(1, phRow, NULL, NULL, NULL),S_OK);
}
CLEANUP:
SAFE_RELEASE(pIRowset);
return hr;
}
BOOL TCRowPosition::VerifyGetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags)
{
TBEGIN
ASSERT(pIRowPosition);
HRESULT hr = E_FAIL;
HCHAPTER hChapter2 = INVALID(HCHAPTER);
HROW hRow2 = INVALID(HROW);
DBPOSITIONFLAGS dwPosFlags2 = INVALID(DBPOSITIONFLAGS);
//GetRowPosition (delegate)
TESTC_(hr = GetRowPosition(pIRowPosition, &hChapter2, &hRow2, &dwPosFlags2),S_OK);
//Verify results
TESTC(hChapter == hChapter2);
TESTC(hRow == hRow2);
TESTC(dwPosFlags== dwPosFlags2);
CLEANUP:
TRETURN
}
BOOL TCRowPosition::VerifySetRowPosition(IRowPosition* pIRowPosition, HCHAPTER hChapter, HROW hRow, DBPOSITIONFLAGS dwPosFlags)
{
TBEGIN
ASSERT(pIRowPosition);
HRESULT hr = E_FAIL;
//SetRowPosition (delegate)
TESTC_(hr = SetRowPosition(pIRowPosition, hChapter, hRow, dwPosFlags),S_OK);
//Delegate to our Get Method
TESTC(VerifyGetRowPosition(pIRowPosition, hChapter, hRow, dwPosFlags));
CLEANUP:
TRETURN
}
IRowPosition* const TCRowPosition::pIRowPos()
{
ASSERT(m_pIRowPosition);
return m_pIRowPosition;
}
IConnectionPointContainer* const TCRowPosition::pICPC()
{
ASSERT(m_pIConnectionPointContainer);
return m_pIConnectionPointContainer;
}
IConnectionPoint* const TCRowPosition::pICP()
{
ASSERT(m_pIConnectionPoint);
return m_pIConnectionPoint;
}
IEnumConnectionPoints* const TCRowPosition::pIEnumCP()
{
ASSERT(m_pIEnumConnectionPoints);
return m_pIEnumConnectionPoints;
}
BOOL TCRowPosition::VerifyDiffCookies(ULONG cCookies, DWORD* rgCookie) const
{
//NOTE: When calling this method you should only be checking Cookies from
//the same Container, since Cookies may not be unqiue accross Containers.
//verify different connection cookies
for(ULONG i=0; i<cCookies; i++)
for(ULONG j=i+1; j<cCookies; j++)
if(rgCookie[i] == rgCookie[j])
return FALSE;
return TRUE;
}
BOOL TCRowPosition::AdviseAll(ULONG* rgCookies, IRowPosition* pIRowPosition)
{
TBEGIN
if(pIRowPosition== NULL)
pIRowPosition = m_pIRowPosition;
ASSERT(rgCookies);
ASSERT(pIRowPosition);
//Advise all Listeners to the IRowPosition object
for(ULONG i=0; i<m_cListeners; i++)
{
TESTC(m_rgpListeners[i]->Restart());
TESTC_(m_rgpListeners[i]->Advise(&rgCookies[i], pIRowPosition),S_OK);
TESTC(rgCookies[i] != 0);
}
//Make sure all Cookies are unique
TESTC(VerifyDiffCookies(m_cListeners, rgCookies));
CLEANUP:
TRETURN
}
BOOL TCRowPosition::UnadviseAll(ULONG* rgCookies, IRowPosition* pIRowPosition)
{
TBEGIN
if(pIRowPosition== NULL)
pIRowPosition = m_pIRowPosition;
ASSERT(rgCookies);
ASSERT(pIRowPosition);
//Unadvise all Listeners from the IRowPosition object
for(ULONG i=0; i<m_cListeners; i++)
{
TESTC(rgCookies[i] != 0);
TESTC_(m_rgpListeners[i]->Unadvise(rgCookies[i], pIRowPosition),S_OK);
}
CLEANUP:
TRETURN
}
BOOL TCRowPosition::VerifyTimesNotified(ULONG cTimes, DBREASON eReason, DBEVENTPHASE ePhase)
{
TBEGIN
//Determine the number of times notified for this notification
for(ULONG i=0; i<m_cListeners; i++)
{
QTESTC(m_rgpListeners[i]->GetTimesNotified(eReason, ePhase) == cTimes);
}
CLEANUP:
TRETURN
}
BOOL TCRowPosition::RestartListeners()
{
TBEGIN
//Determine the number of times notified for this notification
for(ULONG i=0; i<m_cListeners; i++)
{
TESTC(m_rgpListeners[i]->Restart());
}
CLEANUP:
TRETURN
}
BOOL TCRowPosition::ResetTimesNotified()
{
TBEGIN
//Determine the number of times notified for this notification
for(ULONG i=0; i<m_cListeners; i++)
{
TESTC(m_rgpListeners[i]->ResetTimesNotified());
}
CLEANUP:
TRETURN
}
BOOL TCRowPosition::VerifyFailedTodo(DBREASON eReason, DBEVENTPHASE ePhase)
{
TBEGIN
ULONG i=0;
//This is kind of a difficult method.
//We need to verify that there was a FAILEDTODO on the particular reason/phase
//The problem is the we also need to verify all previous phases.
//The interesting issue, is that depending upon the order, (who sent the FAILEDTODO)
//Some listeners may have received more notiifcations than others.
//Also if it was the OKTODO phase, some listeners may never receive a FAILEDTODO
//phase, since they were never notified of an event to begin with...
//First just verify that everyone did in fact see a FAILEDTODO
if(ePhase == DBEVENTPHASE_OKTODO)
{
//If started receiveing notifications, then they should have FAILEDTODO
for(i=0; i<m_cListeners; i++)
{
if(m_rgpListeners[i]->GetTimesNotified(eReason))
{
TESTC(m_rgpListeners[i]->GetTimesNotified(eReason, DBEVENTPHASE_FAILEDTODO)==1);
}
}
}
else
{
//Simple, just verify everyone saw a FAILEDTODO
TESTC(VerifyTimesNotified(1, eReason, DBEVENTPHASE_FAILEDTODO));
}
//Now verify the listeners received all phases upto the FAILEDTODO
//For the first Notifications...
switch(ePhase)
{
case DBEVENTPHASE_ABOUTTODO:
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
break;
case DBEVENTPHASE_SYNCHAFTER:
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
break;
case DBEVENTPHASE_DIDEVENT:
case DBEVENTPHASE_FAILEDTODO:
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
break;
};
CLEANUP:
TRETURN
}
BOOL TCRowPosition::VerifyConnectData(ULONG cConnectData, CONNECTDATA* rgConnectData, ULONG cCookies, IUnknown** rgpListeners, DWORD* rgCookies)
{
ASSERT(rgConnectData);
ASSERT(rgpListeners);
ASSERT(rgCookies);
//Need to verify rgConnectData array contains the correct information
//NOTE: rgConnectData doesn't have to be ordered direclty with the order
//that the connections were established.
//NOTE: this function assumes that rgCookies is in the same order as rgpListeners.
ULONG ulFound = 0;
//Loop over the ConnectData
for(ULONG i=0; i<cConnectData; i++)
{
//Must at least be in the valid range for Sink/Cookie!
if(rgConnectData[i].pUnk == NULL || rgConnectData[i].dwCookie == 0)
return FALSE;
//Try to find the cookie in the list of cookies.
//Once the cookie is found, lookup the corresponding listener
for(ULONG j=0; j<cCookies; j++)
{
if(rgConnectData[i].dwCookie==rgCookies[j])
{
if(!VerifyEqualInterface(rgConnectData[i].pUnk, rgpListeners[j]))
return FALSE;
ulFound++;
}
}
}
return ulFound == cConnectData;
}
BOOL TCRowPosition::FreeConnectData(ULONG cConnectData, CONNECTDATA* rgConnectData)
{
//Loop over the ConnectData
for(ULONG i=0; i<cConnectData; i++)
{
SAFE_RELEASE(rgConnectData[i].pUnk);
}
return TRUE;
}
ULONG TCRowPosition::Thread_CreateRowPosition(LPVOID pv)
{
THREAD_BEGIN
CRowset* pThis = (TCRowPosition*)THREAD_FUNC;
ASSERT(pThis);
//Local stack variables
IRowPosition* pIRowPosition = NULL;
ThreadSwitch(); //Let the other thread(s) catch up
//CreateInstance
TESTC_(CreateRowPosition(pThis->pIRowset(), &pIRowPosition),S_OK);
ThreadSwitch(); //Let the other thread(s) catch up
CLEANUP:
SAFE_RELEASE(pIRowPosition);
THREAD_RETURN
}
ULONG TCRowPosition::Thread_Initialize(LPVOID pv)
{
THREAD_BEGIN
TCRowPosition* pThis = (TCRowPosition*)THREAD_FUNC;
IRowPosition* pIRowPosition = (IRowPosition*)THREAD_ARG1;
ASSERT(pThis && pIRowPosition);
HRESULT hr = E_FAIL;
ThreadSwitch(); //Let the other thread(s) catch up
hr = Initialize(pIRowPosition, pThis->pIRowset());
TESTC(hr==S_OK || hr==DB_E_ALREADYINITIALIZED);
ThreadSwitch(); //Let the other thread(s) catch up
CLEANUP:
THREAD_RETURN
}
ULONG TCRowPosition::Thread_GetRowset(LPVOID pv)
{
THREAD_BEGIN
TCRowPosition* pThis = (TCRowPosition*)THREAD_FUNC;
IRowPosition* pIRowPosition = (IRowPosition*)THREAD_ARG1;
ASSERT(pThis && pIRowPosition);
IRowset* pIRowset = NULL;
ThreadSwitch(); //Let the other thread(s) catch up
TESTC_(GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset),S_OK);
ThreadSwitch(); //Let the other thread(s) catch up
CLEANUP:
SAFE_RELEASE(pIRowset);
THREAD_RETURN
}
ULONG TCRowPosition::Thread_GetRowPosition(LPVOID pv)
{
THREAD_BEGIN
TCRowPosition* pThis = (TCRowPosition*)THREAD_FUNC;
IRowPosition* pIRowPosition = (IRowPosition*)THREAD_ARG1;
ASSERT(pThis && pIRowPosition);
HRESULT hr = S_OK;
HCHAPTER hChapter = NULL;
HROW hRow = NULL;
DBPOSITIONFLAGS dwPositionFlags = 0;
ThreadSwitch(); //Let the other thread(s) catch up
//GetRowPosition
TESTC_(hr = GetRowPosition(pIRowPosition, &hChapter, &hRow, &dwPositionFlags),S_OK);
//TODO what should I be checking here for results?
ThreadSwitch(); //Let the other thread(s) catch up
CLEANUP:
THREAD_RETURN
}
ULONG TCRowPosition::Thread_ClearSetGetCombo(LPVOID pv)
{
THREAD_BEGIN
TCRowPosition* pThis = (TCRowPosition*)THREAD_FUNC;
IRowPosition* pIRowPosition = (IRowPosition*)THREAD_ARG1;
HROW* phRow = (HROW*)THREAD_ARG2;
ASSERT(pThis && pIRowPosition && phRow && *phRow);
HRESULT hr = S_OK;
HROW hRow = *phRow;
HCHAPTER hChapter = NULL;
DBPOSITIONFLAGS dwPositionFlags;
ThreadSwitch(); //Let the other thread(s) catch up
//ClearRowPosition
hr = ClearRowPosition(pIRowPosition);
//SetRowPosition
hr = SetRowPosition(pIRowPosition, NULL, hRow, DBPOSITION_OK);
//GetRowPosition
hr = GetRowPosition(pIRowPosition, &hChapter, &hRow, &dwPositionFlags);
ThreadSwitch(); //Let the other thread(s) catch up
THREAD_RETURN
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_TEST_CASE_MAP(TCInitialize)
//--------------------------------------------------------------------
// @class Initializes the IRowPosition
//
class TCInitialize : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCInitialize,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - Call Initialize with all valid rowset interfaces
int Variation_1();
// @cmember General - Call Initialize with something that does not support IRowset
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Boundary - Initialize with a null pointer
int Variation_4();
// @cmember Boundary - Call with an IDispatch
int Variation_5();
// @cmember Boundary - Other non rowset objects
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember Sequence - Call Initialize twice in a row
int Variation_8();
// @cmember Sequence - Call Initialize the second time with an IUnknown
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Stress - Initialize with 3 IRowPositions to the same SourceRowset
int Variation_11();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCInitialize)
#define THE_CLASS TCInitialize
BEG_TEST_CASE(TCInitialize, TCRowPosition, L"Initializes the IRowPosition")
TEST_VARIATION(1, L"General - Call Initialize with all valid rowset interfaces")
TEST_VARIATION(2, L"General - Call Initialize with something that does not support IRowset")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Boundary - Initialize with a null pointer")
TEST_VARIATION(5, L"Boundary - Call with an IDispatch")
TEST_VARIATION(6, L"Boundary - Other non rowset objects")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"Sequence - Call Initialize twice in a row")
TEST_VARIATION(9, L"Sequence - Call Initialize the second time with an IUnknown")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Stress - Initialize with 3 IRowPositions to the same SourceRowset")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCGetRowset)
//--------------------------------------------------------------------
// @class Returns the current underlying Rowset
//
class TCGetRowset : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCGetRowset,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - After Initialization, call GetRowset with riid valid.
int Variation_1();
// @cmember General - Call GetRowset with IUnknown
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Boundary - Before initialization, call GetRowset with riid null.
int Variation_4();
// @cmember Boundary - Before initialization call GetRowset with riid valid
int Variation_5();
// @cmember Boundary - After Initialization, call GetRowset with riid invalid
int Variation_6();
// @cmember Boundary - Make sure the rowset was AddReffed, by killing the IRowPos, and making sure the Rowset is still valid.
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember Related - Initialize another IRowPosition with GetRowset from the first one
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Multithreaded - CoCreateInstance, Initialize
int Variation_11();
// @cmember Multithreaded - Initialize
int Variation_12();
// @cmember Multithreaded - GetRowset
int Variation_13();
// @cmember Multithreaded - GetRowPosition
int Variation_14();
// @cmember Multithreaded - Clear,Set,Get RowPosition Combo
int Variation_15();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCGetRowset)
#define THE_CLASS TCGetRowset
BEG_TEST_CASE(TCGetRowset, TCRowPosition, L"Returns the current underlying Rowset")
TEST_VARIATION(1, L"General - After Initialization, call GetRowset with riid valid.")
TEST_VARIATION(2, L"General - Call GetRowset with IUnknown")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Boundary - Before initialization, call GetRowset with riid null.")
TEST_VARIATION(5, L"Boundary - Before initialization call GetRowset with riid valid")
TEST_VARIATION(6, L"Boundary - After Initialization, call GetRowset with riid invalid")
TEST_VARIATION(7, L"Boundary - Make sure the rowset was AddReffed, by killing the IRowPos, and making sure the Rowset is still valid.")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"Related - Initialize another IRowPosition with GetRowset from the first one")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Multithreaded - CoCreateInstance, Initialize")
TEST_VARIATION(12, L"Multithreaded - Initialize")
TEST_VARIATION(13, L"Multithreaded - GetRowset")
TEST_VARIATION(14, L"Multithreaded - GetRowPosition")
TEST_VARIATION(15, L"Multithreaded - Clear,Set,Get RowPosition Combo")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCClearRowPosition)
//--------------------------------------------------------------------
// @class Clears the value of the current hRow
//
class TCClearRowPosition : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCClearRowPosition,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - Call ClearRowPosition after a call to SetRowPosition
int Variation_1();
// @cmember General - Call ClearRowPosition directly after an Init.
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Boundary - Call ClearRowPosition before any calls to Init
int Variation_4();
// @cmember Empty
int Variation_5();
// @cmember Sequence - Call ClearRowPosition twice in a row
int Variation_6();
// @cmember Sequence - Call ClearRowPosition, then a GetRowPosition
int Variation_7();
// @cmember Sequence - Call ClearRowPosition, then a GetnextRows
int Variation_8();
// @cmember Empty
int Variation_9();
// @cmember Multiuser - ClearRowPosition should not affect other IRowPosition's
int Variation_10();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCClearRowPosition)
#define THE_CLASS TCClearRowPosition
BEG_TEST_CASE(TCClearRowPosition, TCRowPosition, L"Clears the value of the current hRow")
TEST_VARIATION(1, L"General - Call ClearRowPosition after a call to SetRowPosition")
TEST_VARIATION(2, L"General - Call ClearRowPosition directly after an Init.")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Boundary - Call ClearRowPosition before any calls to Init")
TEST_VARIATION(5, L"Empty")
TEST_VARIATION(6, L"Sequence - Call ClearRowPosition twice in a row")
TEST_VARIATION(7, L"Sequence - Call ClearRowPosition, then a GetRowPosition")
TEST_VARIATION(8, L"Sequence - Call ClearRowPosition, then a GetnextRows")
TEST_VARIATION(9, L"Empty")
TEST_VARIATION(10, L"Multiuser - ClearRowPosition should not affect other IRowPosition's")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCSetRowPosition)
//--------------------------------------------------------------------
// @class Sets the current row position
//
class TCSetRowPosition : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCSetRowPosition,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - SetRowPosition to an hRow in the middle of many hRows
int Variation_1();
// @cmember General - SetRowPosition to an hRow in the middle of many hRows with DBPOSITION_NOROW
int Variation_2();
// @cmember General - test all the invalid flag values on valid hRows
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember Boundary - SetRowPosition to null with no rows and DBPOSITION_OK
int Variation_5();
// @cmember Boundary - SetRowPosition to null with no rows and DBPOSITION_NOROW
int Variation_6();
// @cmember Boundary - SetRowPosition to null with no rows and DBPOSITION_BOF
int Variation_7();
// @cmember Boundary - SetRowPosition to null with no rows and DBPOSITION_EOF
int Variation_8();
// @cmember Boundary - SetRowPosition to some hRow with no rows
int Variation_9();
// @cmember Boundary - SetRowPosition to null with one row and DBPOSITION_OK
int Variation_10();
// @cmember Boundary - SetRowPosition to null with one row and DBPOSITION_NOROW
int Variation_11();
// @cmember Boundary - SetRowPosition to null with one row and DBPOSITION_BOF
int Variation_12();
// @cmember Boundary - SetRowPosition to the last row of many
int Variation_13();
// @cmember Boundary - SetRowPosition to the first row of many
int Variation_14();
// @cmember Boundary - SetRowPosition to an invalid (nonexistent
int Variation_15();
// @cmember Boundary - SetRowPosition with a null row handle
int Variation_16();
// @cmember Boundary - SetRowPosition with a deleted row handle
int Variation_17();
// @cmember Empty
int Variation_18();
// @cmember Sequence - Call a valid SetRowPosition in a multi-row scenario after a valid SetRowPosition
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember Multiuser - SetRowPosition with different IRowPositions but with the same sourcerowset
int Variation_21();
// @cmember Multiuser - SetRowPosition with different IRowPositions and with different sourcerowsets
int Variation_22();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCSetRowPosition)
#define THE_CLASS TCSetRowPosition
BEG_TEST_CASE(TCSetRowPosition, TCRowPosition, L"Sets the current row position")
TEST_VARIATION(1, L"General - SetRowPosition to an hRow in the middle of many hRows")
TEST_VARIATION(2, L"General - SetRowPosition to an hRow in the middle of many hRows with DBPOSITION_NOROW")
TEST_VARIATION(3, L"General - test all the invalid flag values on valid hRows")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"Boundary - SetRowPosition to null with no rows and DBPOSITION_OK")
TEST_VARIATION(6, L"Boundary - SetRowPosition to null with no rows and DBPOSITION_NOROW")
TEST_VARIATION(7, L"Boundary - SetRowPosition to null with no rows and DBPOSITION_BOF")
TEST_VARIATION(8, L"Boundary - SetRowPosition to null with no rows and DBPOSITION_EOF")
TEST_VARIATION(9, L"Boundary - SetRowPosition to some hRow with no rows")
TEST_VARIATION(10, L"Boundary - SetRowPosition to null with one row and DBPOSITION_OK")
TEST_VARIATION(11, L"Boundary - SetRowPosition to null with one row and DBPOSITION_NOROW")
TEST_VARIATION(12, L"Boundary - SetRowPosition to null with one row and DBPOSITION_BOF")
TEST_VARIATION(13, L"Boundary - SetRowPosition to the last row of many")
TEST_VARIATION(14, L"Boundary - SetRowPosition to the first row of many")
TEST_VARIATION(15, L"Boundary - SetRowPosition to an invalid (nonexistent")
TEST_VARIATION(16, L"Boundary - SetRowPosition with a null row handle")
TEST_VARIATION(17, L"Boundary - SetRowPosition with a deleted row handle")
TEST_VARIATION(18, L"Empty")
TEST_VARIATION(19, L"Sequence - Call a valid SetRowPosition in a multi-row scenario after a valid SetRowPosition")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"Multiuser - SetRowPosition with different IRowPositions but with the same sourcerowset")
TEST_VARIATION(22, L"Multiuser - SetRowPosition with different IRowPositions and with different sourcerowsets")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCGetRowPosition)
//--------------------------------------------------------------------
// @class Returns the current row possition
//
class TCGetRowPosition : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCGetRowPosition,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - GetRowPosition with one row, hRow set.
int Variation_1();
// @cmember General - Make sure it AddRefs the hRows.
int Variation_2();
// @cmember General - GetRowPosition immediately after an Initialize.
int Variation_3();
// @cmember General - GetRowPosition before an Initialize.
int Variation_4();
// @cmember General - GetRowPosition after a ClearRowPosition.
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Parameters - GetRowPosition with hChapter NULL
int Variation_7();
// @cmember Parameters - GetRowPosition with phRow NULL
int Variation_8();
// @cmember Parameters - GetRowPosition with pdwPositionFlags NULL
int Variation_9();
// @cmember Parameters - GetRowPosition with all params NULL
int Variation_10();
// @cmember Empty
int Variation_11();
// @cmember Multiuser - Call GetNextRows with multiple IRowPositions.
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Related - Make sure GetnextRows is not being interfered with
int Variation_14();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCGetRowPosition)
#define THE_CLASS TCGetRowPosition
BEG_TEST_CASE(TCGetRowPosition, TCRowPosition, L"Returns the current row possition")
TEST_VARIATION(1, L"General - GetRowPosition with one row, hRow set.")
TEST_VARIATION(2, L"General - Make sure it AddRefs the hRows.")
TEST_VARIATION(3, L"General - GetRowPosition immediately after an Initialize.")
TEST_VARIATION(4, L"General - GetRowPosition before an Initialize.")
TEST_VARIATION(5, L"General - GetRowPosition after a ClearRowPosition.")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Parameters - GetRowPosition with hChapter NULL")
TEST_VARIATION(8, L"Parameters - GetRowPosition with phRow NULL")
TEST_VARIATION(9, L"Parameters - GetRowPosition with pdwPositionFlags NULL")
TEST_VARIATION(10, L"Parameters - GetRowPosition with all params NULL")
TEST_VARIATION(11, L"Empty")
TEST_VARIATION(12, L"Multiuser - Call GetNextRows with multiple IRowPositions.")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Related - Make sure GetnextRows is not being interfered with")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddRelease)
//--------------------------------------------------------------------
// @class Testing AddRef, Release, and QI
//
class TCAddRelease : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddRelease,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember AddRef - Make sure it increments
int Variation_1();
// @cmember AddRef - 100 times, and make sure it increments
int Variation_2();
// @cmember AddRef - and Release combo 100 times
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember Release - Make sure it decrements
int Variation_5();
// @cmember Release - 100 times and make sure it decrements
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember QI - for IRowPosition
int Variation_8();
// @cmember QI - for someting non-existent
int Variation_9();
// @cmember QI - for IUnknown
int Variation_10();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCAddRelease)
#define THE_CLASS TCAddRelease
BEG_TEST_CASE(TCAddRelease, TCRowPosition, L"Testing AddRef, Release, and QI")
TEST_VARIATION(1, L"AddRef - Make sure it increments")
TEST_VARIATION(2, L"AddRef - 100 times, and make sure it increments")
TEST_VARIATION(3, L"AddRef - and Release combo 100 times")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"Release - Make sure it decrements")
TEST_VARIATION(6, L"Release - 100 times and make sure it decrements")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"QI - for IRowPosition")
TEST_VARIATION(9, L"QI - for someting non-existent")
TEST_VARIATION(10, L"QI - for IUnknown")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCOnRowPositionChange)
//--------------------------------------------------------------------
// @class Functions that are called when a row changes
//
class TCOnRowPositionChange : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCOnRowPositionChange,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General - return S_OK
int Variation_1();
// @cmember General - return S_FALSE
int Variation_2();
// @cmember General - return S_FALSE on an fCantDeny.
int Variation_3();
// @cmember General - return DB_S_UNWANTEDPHASE
int Variation_4();
// @cmember General - return DB_S_UNWANTEDREASON
int Variation_5();
// @cmember General - return E_FAIL
int Variation_6();
// @cmember General - return E_OUTOFMEMORY
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember Test in all four phases
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Sequence - Advise inbetween seperate notifications
int Variation_11();
// @cmember Sequence - Advise during a notification
int Variation_12();
// @cmember Sequence - Unadvise inbetween seperate notification
int Variation_13();
// @cmember Sequence - Unadvise during a notification
int Variation_14();
// @cmember Empty
int Variation_15();
// @cmember SetRowPosition - Error Cases - FAILEDTODO
int Variation_16();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCOnRowPositionChange)
#define THE_CLASS TCOnRowPositionChange
BEG_TEST_CASE(TCOnRowPositionChange, TCRowPosition, L"Functions that are called when a row changes")
TEST_VARIATION(1, L"General - return S_OK")
TEST_VARIATION(2, L"General - return S_FALSE")
TEST_VARIATION(3, L"General - return S_FALSE on an fCantDeny.")
TEST_VARIATION(4, L"General - return DB_S_UNWANTEDPHASE")
TEST_VARIATION(5, L"General - return DB_S_UNWANTEDREASON")
TEST_VARIATION(6, L"General - return E_FAIL")
TEST_VARIATION(7, L"General - return E_OUTOFMEMORY")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"Test in all four phases")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Sequence - Advise inbetween seperate notifications")
TEST_VARIATION(12, L"Sequence - Advise during a notification")
TEST_VARIATION(13, L"Sequence - Unadvise inbetween seperate notification")
TEST_VARIATION(14, L"Sequence - Unadvise during a notification")
TEST_VARIATION(15, L"Empty")
TEST_VARIATION(16, L"SetRowPosition - Error Cases - FAILEDTODO")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCConnectionStuff)
//--------------------------------------------------------------------
// @class Testing all the connection routines
//
class TCConnectionStuff : public TCRowPosition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCConnectionStuff,TCRowPosition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember General: Container: QI for IID_IConnectionPointContainer
int Variation_1();
// @cmember Container: AddRef
int Variation_2();
// @cmember Container: Release
int Variation_3();
// @cmember Container: FindConnectionPoint for a connection
int Variation_4();
// @cmember Container EnumConnectionPoints
int Variation_5();
// @cmember Container: Next should work until there are no more
int Variation_6();
// @cmember Container: Clone
int Variation_7();
// @cmember Container: Reset should go to the beginning
int Variation_8();
// @cmember Container: The Second one should still be on the end
int Variation_9();
// @cmember Container: Skip should skip one
int Variation_10();
// @cmember Connections: EnumConnections
int Variation_11();
// @cmember Connections: Next should work until there are no more
int Variation_12();
// @cmember Connections: Clone
int Variation_13();
// @cmember Conenctions: Reset should go to the beginning
int Variation_14();
// @cmember Connections: Skip should skip one
int Variation_15();
// @cmember Point: GetConnectionInterface should return succesful
int Variation_16();
// @cmember Point: GetConnectionPointContainer should work with a valid pointer
int Variation_17();
// @cmember B/NULL: Container: QI for IID_NULL
int Variation_18();
// @cmember Container: FindConnectionPoint for IID_NULL
int Variation_19();
// @cmember Container: FindConnectionPoint for ppCP is NULL
int Variation_20();
// @cmember Enum: Next with a rgpcd NULL
int Variation_21();
// @cmember Enum: Skip on the second one should still be at the end
int Variation_22();
// @cmember Container: Enum should fail for a NULL pointer
int Variation_23();
// @cmember Enum: reset twice in a row
int Variation_24();
// @cmember Enum: clone where ppIEnum is NULL
int Variation_25();
// @cmember Point: GetConectionInterface with pIID NULL
int Variation_26();
// @cmember Point: GetConectionPointContainer with ppCPC null
int Variation_27();
// @cmember Point: Unadvise before advising should fail
int Variation_28();
// @cmember Point: advise with pointers NULL
int Variation_29();
// @cmember point: Unadvise with pointers NULL
int Variation_30();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCConnectionStuff)
#define THE_CLASS TCConnectionStuff
BEG_TEST_CASE(TCConnectionStuff, TCRowPosition, L"Testing all the connection routines")
TEST_VARIATION(1, L"General: Container: QI for IID_IConnectionPointContainer")
TEST_VARIATION(2, L"Container: AddRef")
TEST_VARIATION(3, L"Container: Release")
TEST_VARIATION(4, L"Container: FindConnectionPoint for a connection")
TEST_VARIATION(5, L"Container EnumConnectionPoints")
TEST_VARIATION(6, L"Container: Next should work until there are no more")
TEST_VARIATION(7, L"Container: Clone")
TEST_VARIATION(8, L"Container: Reset should go to the beginning")
TEST_VARIATION(9, L"Container: The Second one should still be on the end")
TEST_VARIATION(10, L"Container: Skip should skip one")
TEST_VARIATION(11, L"Connections: EnumConnections")
TEST_VARIATION(12, L"Connections: Next should work until there are no more")
TEST_VARIATION(13, L"Connections: Clone")
TEST_VARIATION(14, L"Conenctions: Reset should go to the beginning")
TEST_VARIATION(15, L"Connections: Skip should skip one")
TEST_VARIATION(16, L"Point: GetConnectionInterface should return succesful")
TEST_VARIATION(17, L"Point: GetConnectionPointContainer should work with a valid pointer")
TEST_VARIATION(18, L"B/NULL: Container: QI for IID_NULL")
TEST_VARIATION(19, L"Container: FindConnectionPoint for IID_NULL")
TEST_VARIATION(20, L"Container: FindConnectionPoint for ppCP is NULL")
TEST_VARIATION(21, L"Enum: Next with a rgpcd NULL")
TEST_VARIATION(22, L"Enum: Skip on the second one should still be at the end")
TEST_VARIATION(23, L"Container: Enum should fail for a NULL pointer")
TEST_VARIATION(24, L"Enum: reset twice in a row")
TEST_VARIATION(25, L"Enum: clone where ppIEnum is NULL")
TEST_VARIATION(26, L"Point: GetConectionInterface with pIID NULL")
TEST_VARIATION(27, L"Point: GetConectionPointContainer with ppCPC null")
TEST_VARIATION(28, L"Point: Unadvise before advising should fail")
TEST_VARIATION(29, L"Point: advise with pointers NULL")
TEST_VARIATION(30, L"point: Unadvise with pointers NULL")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCTransactions)
//*-----------------------------------------------------------------------
// @class Testing RowPos within transactions
//
class TCTransactions : public CTransaction {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCTransactions,CTransaction);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember COMMIT - fRetaning == TRUE
int Variation_1();
// @cmember COMMIT - fRetaning == FALSE
int Variation_2();
// @cmember ABORT - fRetaning == TRUE
int Variation_3();
// @cmember ABORT - fRetaning == FALSE
int Variation_4();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCTransactions)
#define THE_CLASS TCTransactions
BEG_TEST_CASE(TCTransactions, CTransaction, L"Testing RowPos within transactions")
TEST_VARIATION(1, L"COMMIT - fRetaning == TRUE")
TEST_VARIATION(2, L"COMMIT - fRetaning == FALSE")
TEST_VARIATION(3, L"ABORT - fRetaning == TRUE")
TEST_VARIATION(4, L"ABORT - fRetaning == FALSE")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(9, ThisModule, gwszModuleDescrip)
TEST_CASE(1, TCInitialize)
TEST_CASE(2, TCGetRowset)
TEST_CASE(3, TCClearRowPosition)
TEST_CASE(4, TCSetRowPosition)
TEST_CASE(5, TCGetRowPosition)
TEST_CASE(6, TCAddRelease)
TEST_CASE(7, TCOnRowPositionChange)
TEST_CASE(8, TCConnectionStuff)
TEST_CASE(9, TCTransactions)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
// {{ TCW_TC_PROTOTYPE(TCInitialize)
//*-----------------------------------------------------------------------
//| Test Case: TCInitialize - Initializes the IRowPosition
//| Created: 06/10/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCInitialize::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - Call Initialize with all valid rowset interfaces
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_1()
{
TBEGIN
IUnknown* pIUnkRowset = NULL;
//Initialize the RowPosition. It should return S_OK.
TESTC_(CreateRowPosition(pIRowset()),S_OK);
//Rowset IUnknown
TESTC_(QI(pIRowset(), IID_IUnknown, (void**)&pIUnkRowset),S_OK);
TESTC_(CreateRowPosition(pIUnkRowset), S_OK);
CLEANUP:
SAFE_RELEASE(pIUnkRowset);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - Call Initialize with something that does not support IRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_2()
{
TBEGIN
IUnknown* pIUnkPos = NULL;
//Non-rowset IUnknown
TESTC_(QI(pIRowPos(), IID_IUnknown, (void**)&pIUnkPos),S_OK);
TESTC_(CreateRowPosition(pIUnkPos), E_NOINTERFACE);
CLEANUP:
SAFE_RELEASE(pIUnkPos);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_3()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Initialize with a null pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_4()
{
TBEGIN
TESTC_(CreateRowPosition(NULL), E_INVALIDARG);
TESTC_(CreateRowPosition(g_pIDBInitialize),E_NOINTERFACE);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Call with an IDispatch
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_5()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IDispatch* pIDispatch = NULL;
IRowset* pIRowsetUnk = NULL;
HRESULT hr = E_FAIL;
//Create RowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
hr = pIRowPosition->GetRowset(IID_IDispatch, (IUnknown**)&pIDispatch);
//Verify results
//Not all providers rowsets have to support IDispatch
if( hr == E_NOINTERFACE )
{
TESTC(pIDispatch == NULL);
}
if( hr == S_OK )
{
TESTC( pIDispatch != NULL);
TESTC_(QI(pIDispatch, IID_IRowset, (void**)&pIRowsetUnk),S_OK);
TESTC( pIRowsetUnk != NULL);
}
CLEANUP:
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowsetUnk);
SAFE_RELEASE(pIDispatch);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Other non rowset objects
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_6()
{
//Since we are using Schema and Sources Rowsets, this variation will be different.
TBEGIN
ISourcesRowset* pISourcesRowset= NULL;
IRowsetInfo* pIRowsetInfo = NULL;
//Get a SchemaRowset and test it.
CRowset RowsetA;
TESTC_PROVIDER(RowsetA.CreateRowset(SELECT_DBSCHEMA_TABLE)==S_OK);
TESTC_(CreateRowPosition(RowsetA()),S_OK);
//How about with a pointer to the Enumerator...
TESTC_(CoCreateInstance(CLSID_OLEDB_ENUMERATOR, NULL, CLSCTX_INPROC_SERVER, IID_ISourcesRowset, (void**)&pISourcesRowset),S_OK);
TESTC_(CreateRowPosition(pISourcesRowset),E_NOINTERFACE);
//But the rowset from the Enumerator should be successful
TESTC_(pISourcesRowset->GetSourcesRowset(NULL, IID_IRowsetInfo, 0, NULL, (IUnknown**)&pIRowsetInfo),S_OK);
TESTC_(CreateRowPosition(pIRowsetInfo),S_OK);
CLEANUP:
SAFE_RELEASE(pISourcesRowset);
SAFE_RELEASE(pIRowsetInfo);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_7()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call Initialize twice in a row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_8()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(pIRowPosition->Initialize(pIRowset()),DB_E_ALREADYINITIALIZED);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call Initialize the second time with an IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_9()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
//get the IUnknown off of the other pIRowPosition.
TESTC_(QI(pIRowPos(), IID_IRowPosition, (void**)&pIRowPosition),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition2),S_OK);
//Second Init... .should fail
TESTC_(pIRowPos()->Initialize(pIRowPosition),DB_E_ALREADYINITIALIZED);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_10()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Stress - Initialize with 3 IRowPositions to the same SourceRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCInitialize::Variation_11()
{
//Can we init 3 RowPosition's to one Rowset?
TBEGIN
IRowPosition* rgpIRowPosition[3] = {NULL,NULL,NULL};
ULONG i;
for(i=0; i<3; i++)
{
TESTC_(CreateRowPosition(pIRowset(), &rgpIRowPosition[i]),S_OK);
}
CLEANUP:
for(i=0; i<3; i++ )
SAFE_RELEASE(rgpIRowPosition[i]);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCInitialize::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCGetRowset)
//*-----------------------------------------------------------------------
//| Test Case: TCGetRowset - Returns the current underlying Rowset
//| Created: 06/10/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCGetRowset::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - After Initialization, call GetRowset with riid valid.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_1()
{
TBEGIN
IUnknown* pIUnknown = NULL;
//Call GetRowset for the IRowset
TESTC_(pIRowPos()->GetRowset(IID_IRowset, &pIUnknown),S_OK);
TESTC(pIUnknown == pIRowset());
CLEANUP:
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - Call GetRowset with IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_2()
{
TBEGIN
IUnknown* pIUnknown = NULL;
IUnknown* pIUnknown2 = NULL;
TESTC_(pIRowPos()->GetRowset(IID_IUnknown, &pIUnknown),S_OK);
TESTC_(QI(pIRowset(), IID_IUnknown, (void**)&pIUnknown2),S_OK);
TESTC(pIUnknown == pIUnknown2);
CLEANUP:
SAFE_RELEASE(pIUnknown);
SAFE_RELEASE(pIUnknown2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_3()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Before initialization, call GetRowset with riid null.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_4()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IUnknown* pIUnknown = NULL;
//Create new instance
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPosition, (LPVOID *)&pIRowPosition),S_OK);
TESTC_(pIRowPosition->GetRowset(IID_NULL, &pIUnknown),E_UNEXPECTED);
TESTC(pIUnknown == NULL);
TESTC_(pIRowPosition->GetRowset(IID_IRowset, &pIUnknown),E_UNEXPECTED);
TESTC(pIUnknown == NULL);
//Valid cases with CoCreateInstance
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&pIUnknown),S_OK);
TESTC(pIUnknown != NULL);
SAFE_RELEASE(pIUnknown);
//Invalid cases with CoCreateInstance
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowset, (LPVOID *)&pIUnknown), E_NOINTERFACE);
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IDBInitialize, (LPVOID *)&pIUnknown), E_NOINTERFACE);
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPositionChange, (LPVOID *)&pIUnknown), E_NOINTERFACE);
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IConnectionPointContainer, (LPVOID *)&pIUnknown), S_OK);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Before initialization call GetRowset with riid valid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_5()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IUnknown* pIUnknown= NULL;
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPosition, (LPVOID *)&pIRowPosition),S_OK);
TESTC_(pIRowPosition->GetRowset(IID_IRowset, &pIUnknown),E_UNEXPECTED);
TESTC(pIUnknown == NULL);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Boundary - After Initialization, call GetRowset with riid invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_6()
{
TBEGIN
IUnknown* pIUnknown = NULL;
TESTC_(pIRowPos()->GetRowset(IID_ICommand, &pIUnknown),E_NOINTERFACE);
TESTC(pIUnknown == NULL);
CLEANUP:
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Make sure the rowset was AddReffed, by killing the IRowPos, and making sure the Rowset is still valid.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_7()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IRowset* pIRowsetUnk = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(pIRowPosition->GetRowset(IID_IRowset, (IUnknown**)&pIRowsetUnk),S_OK);
//Make sure rowset is still valid after RowPosition release!
SAFE_RELEASE(pIRowPosition);
TEST2C_(pIRowsetUnk->RestartPosition(NULL),S_OK,DB_S_COMMANDREEXECUTED);
CLEANUP:
SAFE_RELEASE(pIRowsetUnk);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_8()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Related - Initialize another IRowPosition with GetRowset from the first one
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_9()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IUnknown* pIRowset = NULL;
TESTC_(pIRowPos()->GetRowset(IID_IRowset, &pIRowset),S_OK);
TESTC_(CreateRowPosition(pIRowset, &pIRowPosition),S_OK);
CLEANUP:
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_10()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Multithreaded - CoCreateInstance, Initialize
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_11()
{
TBEGIN
INIT_THREADS(THREE_THREADS);
//Setup Thread Arguments
//There are none in this case.
THREADARG T1Arg = { this };
THREADARG T2Arg = { this };
THREADARG T3Arg = { this };
//Create Threads
CREATE_THREAD(THREAD_ONE, Thread_CreateRowPosition,&T1Arg);
CREATE_THREAD(THREAD_TWO, Thread_CreateRowPosition,&T2Arg);
CREATE_THREAD(THREAD_THREE, Thread_CreateRowPosition,&T3Arg);
START_THREADS();
END_THREADS();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Multithreaded - Initialize
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_12()
{
INIT_THREADS(10);
//Setup Thread Arguments
//There are none in this case.
THREADARG T1Arg = { this, pIRowPos() };
//Create Threads
CREATE_THREADS(Thread_Initialize, &T1Arg);
START_THREADS();
END_THREADS();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Multithreaded - GetRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_13()
{
INIT_THREADS(10);
//Setup Thread Arguments
//There are none in this case.
THREADARG T1Arg = { this, pIRowPos() };
//Create Threads
CREATE_THREADS(Thread_GetRowset, &T1Arg);
START_THREADS();
END_THREADS();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Multithreaded - GetRowPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_14()
{
INIT_THREADS(10);
//Setup Thread Arguments
//There are none in this case.
THREADARG T1Arg = { this, pIRowPos() };
//Create Threads
CREATE_THREADS(Thread_GetRowPosition, &T1Arg);
START_THREADS();
END_THREADS();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Multithreaded - Clear,Set,Get RowPosition Combo
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowset::Variation_15()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
INIT_THREADS(10);
//Setup Thread Arguments
//There are none in this case.
THREADARG T1Arg = { this, pIRowPos(), &hRow };
TESTC_(RestartPosition(),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
//Create Threads
CREATE_THREADS(Thread_ClearSetGetCombo, &T1Arg);
START_THREADS();
END_THREADS();
CLEANUP:
ReleaseRows(hRow);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCGetRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCClearRowPosition)
//*-----------------------------------------------------------------------
//| Test Case: TCClearRowPosition - Clears the value of the current hRow
//| Created: 06/13/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCClearRowPosition::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - Call ClearRowPosition after a call to SetRowPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_1()
{
TBEGIN
HROW hRow = 101; //Random start value
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
//Make sure we're at the beginning, and then set to that first row.
TESTC_(RestartPosition(),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(SetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, hRow, DBPOSITION_OK),S_OK);
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC(VerifyGetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
ReleaseRows(hRow);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - Call ClearRowPosition directly after an Init.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_2()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_3()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Boundary - Call ClearRowPosition before any calls to Init
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_4()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPosition, (LPVOID *)&pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_5()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call ClearRowPosition twice in a row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_6()
{
TBEGIN
//Use Local to make sure we know what state it started in.
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call ClearRowPosition, then a GetRowPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_7()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call ClearRowPosition, then a GetnextRows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_8()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
HROW hRow1=DB_NULL_HROW;
HROW hRow2=DB_NULL_HROW;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(),S_OK);
TESTC_(GetNextRows(&hRow1),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(GetNextRows(&hRow2),S_OK);
TESTC(hRow1 != hRow2);
CLEANUP:
ReleaseRows(hRow1);
ReleaseRows(hRow2);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_9()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Multiuser - ClearRowPosition should not affect other IRowPosition's
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCClearRowPosition::Variation_10()
{
TBEGIN
HROW hRow;
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
IRowPosition* pIRowPosition3 = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition2),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition3),S_OK);
TESTC_(RestartPosition(),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition2),S_OK);
TESTC_(ClearRowPosition(pIRowPosition3),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),S_OK);
TESTC_(SetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),S_OK);
TESTC_(SetRowPosition(pIRowPosition3, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),E_UNEXPECTED);
TESTC_(SetRowPosition(pIRowPosition3, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),E_UNEXPECTED);
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
SAFE_RELEASE(pIRowPosition3);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCClearRowPosition::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCSetRowPosition)
//*-----------------------------------------------------------------------
//| Test Case: TCSetRowPosition - Sets the current row position
//| Created: 06/13/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCSetRowPosition::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - SetRowPosition to an hRow in the middle of many hRows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_1()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
//Obtain second row
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC_(GetRow(SECOND_ROW, &hRow),S_OK);
TESTC(VerifySetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - SetRowPosition to an hRow in the middle of many hRows with DBPOSITION_NOROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_2()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(GetRow(SECOND_ROW, &hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_NOROW), E_INVALIDARG);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc General - test all the invalid flag values on valid hRows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_3()
{
// NOTE: Tests both BOF and EOF in one variation
TBEGIN
IRowPosition* pIRowPosition = NULL;
HROW hRow = DB_NULL_HROW;
ULONG i=0;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(),S_OK);
TESTC_(GetRow(SECOND_ROW, &hRow),S_OK);
//DBPOSITION_BOF
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,hRow,DBPOSITION_BOF),E_INVALIDARG);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
//DBPOSITION_EOF
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,hRow,DBPOSITION_EOF),E_INVALIDARG);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
//ULONG_MAX
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,hRow,ULONG_MAX),E_INVALIDARG);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_4()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with no rows and DBPOSITION_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_5()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create Empty rowset
CRowset EmptyRowset;
TESTC_PROVIDER(EmptyRowset.CreateRowset(SELECT_EMPTYROWSET)==S_OK);
TESTC_(CreateRowPosition(EmptyRowset.pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with no rows and DBPOSITION_NOROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_6()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
//Create Empty rowset
CRowset EmptyRowset;
TESTC_PROVIDER(EmptyRowset.CreateRowset(SELECT_EMPTYROWSET)==S_OK);
TESTC_(CreateRowPosition(EmptyRowset.pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_NOROW));
CLEANUP:
EmptyRowset.ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with no rows and DBPOSITION_BOF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_7()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create Empty rowset
CRowset EmptyRowset;
TESTC_PROVIDER(EmptyRowset.CreateRowset(SELECT_EMPTYROWSET)==S_OK);
TESTC_(CreateRowPosition(EmptyRowset.pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_BOF));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with no rows and DBPOSITION_EOF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_8()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create Empty rowset
CRowset EmptyRowset;
TESTC_PROVIDER(EmptyRowset.CreateRowset(SELECT_EMPTYROWSET)==S_OK);
TESTC_(CreateRowPosition(EmptyRowset.pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to some hRow with no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_9()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create Empty rowset
CRowset EmptyRowset;
TESTC_PROVIDER(EmptyRowset.CreateRowset(SELECT_EMPTYROWSET)==S_OK);
TESTC_(CreateRowPosition(EmptyRowset.pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,ULONG_MAX,DBPOSITION_OK),DB_E_BADROWHANDLE);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,ULONG_MAX,DBPOSITION_EOF),E_UNEXPECTED);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with one row and DBPOSITION_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_10()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create 1 row rowset
CRowset Rowset1Row;
TESTC_(Rowset1Row.CreateRowset(SELECT_ALLFROMTBL, IID_IRowset, g_p1RowTable),S_OK);
TESTC_(CreateRowPosition(Rowset1Row(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_OK),E_INVALIDARG);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with one row and DBPOSITION_NOROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_11()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create 1 row rowset
CRowset Rowset1Row;
TESTC_(Rowset1Row.CreateRowset(SELECT_ALLFROMTBL, IID_IRowset, g_p1RowTable),S_OK);
TESTC_(CreateRowPosition(Rowset1Row(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to null with one row and DBPOSITION_BOF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_12()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
//Create 1 row rowset
CRowset Rowset1Row;
TESTC_(Rowset1Row.CreateRowset(SELECT_ALLFROMTBL, IID_IRowset, g_p1RowTable),S_OK);
TESTC_(CreateRowPosition(Rowset1Row(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_BOF));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to the last row of many
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_13()
{
TBEGIN
HROW hRow = NULL;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(),S_OK);
TESTC_(GetRow(m_ulTotalRows, &hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to the first row of many
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_14()
{
TBEGIN
HROW hRow = NULL;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(),S_OK);
TESTC_(GetRow(FIRST_ROW, &hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition to an invalid (nonexistent
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_15()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,123,DBPOSITION_OK),DB_E_BADROWHANDLE);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,123,DBPOSITION_EOF),E_UNEXPECTED);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition with a null row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_16()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_NOROW),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Boundary - SetRowPosition with a deleted row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_17()
{
TBEGIN
HROW hRow = NULL;
IRowPosition* pIRowPosition = NULL;
//Create rowset with IRowsetChange
CRowsetChange RowsetChangeA;
TESTC_PROVIDER(RowsetChangeA.CreateRowset()==S_OK);
TESTC_(CreateRowPosition(RowsetChangeA.pIRowset(), &pIRowPosition),S_OK);
TESTC_(RowsetChangeA.RestartPosition(),S_OK);
//Delete the last row so we don't mess up the first row for the other
//variations. Since some provider may have REMOVEDELETED=FALSE and GetNextRows
//would then return a deleted row...
TESTC_(RowsetChangeA.GetRow(m_ulTotalRows, &hRow),S_OK);
TESTC_(RowsetChangeA.DeleteRow(hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow,DBPOSITION_OK), DB_E_BADROWHANDLE);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
RowsetChangeA.ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_18()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Call a valid SetRowPosition in a multi-row scenario after a valid SetRowPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_19()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(GetRow(SECOND_ROW, &hRow),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK),E_UNEXPECTED);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_20()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Multiuser - SetRowPosition with different IRowPositions but with the same sourcerowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_21()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
HROW hRow = NULL;
HROW hRow2 = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition2),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow,DBPOSITION_OK),S_OK);
TESTC_(ClearRowPosition(pIRowPosition2),S_OK);
TESTC_(GetNextRows(&hRow2),S_OK);
TESTC_(SetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER,hRow2,DBPOSITION_OK),S_OK);
//Verify RowPositons
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
TESTC(VerifyGetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER, hRow2, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
ReleaseRows(hRow2);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Multiuser - SetRowPosition with different IRowPositions and with different sourcerowsets
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCSetRowPosition::Variation_22()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
HROW hRow = NULL;
HROW hRow2 = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition2),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow,DBPOSITION_OK),S_OK);
TESTC_(ClearRowPosition(pIRowPosition2),S_OK);
TESTC_(GetNextRows(&hRow2),S_OK);
TESTC_(SetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER,hRow2,DBPOSITION_OK),S_OK);
//Verify RowPositons
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
TESTC(VerifyGetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER, hRow2, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
ReleaseRows(hRow2);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCSetRowPosition::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCGetRowPosition)
//*-----------------------------------------------------------------------
//| Test Case: TCGetRowPosition - Returns the current row possition
//| Created: 06/16/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCGetRowPosition::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - GetRowPosition with one row, hRow set.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_1()
{
TBEGIN
HROW hRow = DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
//Create Rowset
CRowset RowsetA;
RowsetA.SetProperty(DBPROP_CANHOLDROWS);
TESTC_(RowsetA.CreateRowset(SELECT_ALLFROMTBL, IID_IRowset, g_p1RowTable),S_OK);
TESTC_(CreateRowPosition(RowsetA(), &pIRowPosition),S_OK);
TESTC_(RowsetA.GetRow(FIRST_ROW, &hRow),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifySetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
RowsetA.ReleaseRows(hRow);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - Make sure it AddRefs the hRows.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_2()
{
TBEGIN
HROW hRow = NULL;
IRowPosition* pIRowPosition = NULL;
void* pData = NULL;
HCHAPTER hChapter = NULL;
DBPOSITIONFLAGS dwPositionFlags = 0;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(GetRow(SECOND_ROW, &hRow),S_OK);
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK),S_OK);
TESTC_(GetRowPosition(pIRowPosition, &hChapter, &hRow, &dwPositionFlags),S_OK);
TESTC_(GetRowData(hRow, &pData),S_OK);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
ReleaseRows(hRow);
PROVIDER_FREE(pData);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc General - GetRowPosition immediately after an Initialize.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_3()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC(VerifyGetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc General - GetRowPosition before an Initialize.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_4()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CoCreateInstance(CLSID_OLEDB_ROWPOSITIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, IID_IRowPosition, (LPVOID *)&pIRowPosition),S_OK);
TESTC(VerifyGetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc General - GetRowPosition after a ClearRowPosition.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_5()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_NOROW));
CLEANUP:
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_6()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Parameters - GetRowPosition with hChapter NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_7()
{
TBEGIN
HROW hRow = 101; //Random values.
DBPOSITIONFLAGS dwPositionFlags = 101;
//Spec allow phChapter to be null if is not interested in the hChapter
TESTC_(GetRowPosition(pIRowPos(), NULL, &hRow, &dwPositionFlags), S_OK);
TESTC(hRow == DB_NULL_HROW && dwPositionFlags == DBPOSITION_NOROW);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Parameters - GetRowPosition with phRow NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_8()
{
TBEGIN
HCHAPTER hChapter = 101; //Random values.
DBPOSITIONFLAGS dwPositionFlags = 101;
//E_INVALIDARG - Spec requires phRow
TESTC_(GetRowPosition(pIRowPos(), &hChapter, NULL, &dwPositionFlags),E_INVALIDARG);
TESTC(hChapter == DB_NULL_HCHAPTER && dwPositionFlags == DBPOSITION_NOROW);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Parameters - GetRowPosition with pdwPositionFlags NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_9()
{
TBEGIN
HROW hRow = 101;
HCHAPTER hChapter = 101; //Random values.
//Spec allows pdwPositionFlags = NULL if not interested in dwPosFlags...
TESTC_(GetRowPosition(pIRowPos(), &hChapter, &hRow, NULL), S_OK);
TESTC(hChapter == DB_NULL_HCHAPTER && hRow == DB_NULL_HROW);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Parameters - GetRowPosition with all params NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_10()
{
TBEGIN
TESTC_(GetRowPosition(pIRowPos(), NULL, NULL, NULL),E_INVALIDARG);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_11()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Multiuser - Call GetNextRows with multiple IRowPositions.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_12()
{
TBEGIN
HROW hRow=DB_NULL_HROW;
HROW hRow2=DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition2),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(ClearRowPosition(pIRowPosition2),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(SetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),S_OK);
TESTC_(GetNextRows(&hRow2),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition2, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
ReleaseRows(hRow2);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_13()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Related - Make sure GetnextRows is not being interfered with
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCGetRowPosition::Variation_14()
{
TBEGIN
HROW hRow=DB_NULL_HROW;
HROW hRow2=DB_NULL_HROW;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC_(RestartPosition(NULL),S_OK);
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC_(GetNextRows(&hRow),S_OK);
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,hRow,DBPOSITION_OK),S_OK);
TESTC_(GetNextRows(&hRow2),S_OK);
TESTC(VerifyGetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, hRow, DBPOSITION_OK));
CLEANUP:
ReleaseRows(hRow);
ReleaseRows(hRow2);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCGetRowPosition::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCAddRelease)
//*-----------------------------------------------------------------------
//| Test Case: TCAddRelease - Testing AddRef, Release, and QI
//| Created: 06/23/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddRelease::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc AddRef - Make sure it increments
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_1()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC(pIRowPosition->AddRef() > 0);
TESTC(pIRowPosition->Release() > 0);
TESTC(VerifyRefCounts(pIRowPosition->Release(), 0));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc AddRef - 100 times, and make sure it increments
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_2()
{
TBEGIN
ULONG i=0;
IRowPosition* pIRowPosition = NULL;
//Create RowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
for(i=0; i<100; i++)
{
TESTC(pIRowPosition->AddRef() > 0);
}
for(i=0; i<100; i++)
{
TESTC(pIRowPosition->Release() > 0);
}
TESTC(VerifyRefCounts(pIRowPosition->Release(), 0));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc AddRef - and Release combo 100 times
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_3()
{
TBEGIN
ULONG i=0;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
for(i=0; i<100; i++)
{
TESTC(pIRowPosition->AddRef() > 0);
TESTC(pIRowPosition->Release() > 0);
}
TESTC(VerifyRefCounts(pIRowPosition->Release(), 0));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_4()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Release - Make sure it decrements
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_5()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC(pIRowPosition->AddRef() > 0);
TESTC(pIRowPosition->Release() > 0);
TESTC(VerifyRefCounts(pIRowPosition->Release(), 0));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Release - 100 times and make sure it decrements
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_6()
{
TBEGIN
ULONG i=0;
IRowPosition* pIRowPosition = NULL;
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
for(i=0; i<100; i++)
{
TESTC(pIRowPosition->AddRef() > 0);
}
for(i=0; i<100; i++)
{
TESTC(pIRowPosition->Release() > 0);
}
TESTC(VerifyRefCounts(pIRowPosition->Release(), 0));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_7()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc QI - for IRowPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_8()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IRowPosition* pIRowPosition2 = NULL;
TESTC_(QI(pIRowPos(), IID_IRowPosition, (void**)&pIRowPosition),S_OK);
TESTC_(QI(pIRowPosition, IID_IRowPosition, (void**)&pIRowPosition2),S_OK);
CLEANUP:
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowPosition2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc QI - for someting non-existent
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_9()
{
TBEGIN
IUnknown* pIUnknown = NULL;
TESTC_(QI(pIRowPos(), IID_NULL, (void**)&pIUnknown), E_NOINTERFACE);
TESTC(pIUnknown== NULL);
CLEANUP:
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc QI - for IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddRelease::Variation_10()
{
TBEGIN
IUnknown* pIUnknown = NULL;
IUnknown* pIUnknown2 = NULL;
TESTC_(QI(pIRowPos(), IID_IUnknown, (void**)&pIUnknown),S_OK);
TESTC_(QI(pIUnknown, IID_IUnknown, (void**)&pIUnknown2),S_OK);
TESTC(pIUnknown == pIUnknown2);
CLEANUP:
SAFE_RELEASE(pIUnknown);
SAFE_RELEASE(pIUnknown2);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddRelease::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCOnRowPositionChange)
//*-----------------------------------------------------------------------
//| Test Case: TCOnRowPositionChange - Functions that are called when a row changes
//| Created: 06/23/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCOnRowPositionChange::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General - return S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_1()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc General - return S_FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_2()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Clear RowPosition
TESTC(m_rgpListeners[0]->SetCancel(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
//Verify Results
TESTC(VerifyFailedTodo(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//SetRowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),E_UNEXPECTED);
TESTC(VerifyTimesNotified(0));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
TESTC(VerifyFailedTodo(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc General - return S_FALSE on an fCantDeny.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_3()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
TESTC(m_rgpListeners[0]->SetCancel(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//SetRowPosition
//You cannot veto SYNCHAFTER and DIDEVENT phases of DBREASON_ROWPOSITION_CHANGED
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
//Clear RowPosition
TESTC(ResetTimesNotified());
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc General - return DB_S_UNWANTEDPHASE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_4()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Set which Phases as unwanted (DB_S_UNWANTEDPHASE)
TESTC(m_rgpListeners[0]->SetEvent(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO, FALSE));
TESTC(m_rgpListeners[1]->SetEvent(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO, FALSE));
TESTC(m_rgpListeners[2]->SetEvent(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER, FALSE));
TESTC(m_rgpListeners[0]->SetEvent(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT, FALSE));
TESTC(m_rgpListeners[1]->SetEvent(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_FAILEDTODO, FALSE));
//ClearRowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
//The first time all should have been notified.
//You have to be notified first before you can return DB_S_UNWANTEDPHASE
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//SetRowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
//Now that all phases have been notified, the Provider Should make a
//note of which phases I wasn't interested in and not fire them this time...
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(0 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
//Now that all phases have been notified, the Provider Should make a
//note of which phases I wasn't interested in and not fire them this time...
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
//Now we need to generate the FAILEDTODO phase as well...
TESTC(RestartListeners());
TESTC(m_rgpListeners[0]->SetCancel(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(m_rgpListeners[0]->SetEvent(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO, FALSE));
//Verify results, should all have received FAILEDTODO for the first time
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(ResetTimesNotified());
//Now that all phases have been notified, the Provider Should make a
//note of which phases I wasn't interested in and not fire them this time...
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc General - return DB_S_UNWANTEDREASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_5()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Set which reasons as unwanted (DB_S_UNWANTEDREASON)
TESTC(m_rgpListeners[0]->SetEvent(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ALL, FALSE));
TESTC(m_rgpListeners[0]->SetEvent(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_ALL, FALSE));
TESTC(m_rgpListeners[2]->SetEvent(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_ALL, FALSE));
//ClearRowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
//The first time all should have been notified, for only the first phase
//You have to be notified first before you can return DB_S_UNWANTEDREASON
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//SetRowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
//Now that all phases have been notified, the Provider Should make a
//note of which reasons I wasn't interested in and not fire them this time...
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//Now that all phases have been notified, the Provider Should make a
//note of which phases I wasn't interested in and not fire them this time...
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER,DB_NULL_HROW,DBPOSITION_EOF),S_OK);
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(0 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(0 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
//Now we need to generate the FAILEDTODO phase as well...
TESTC(ResetTimesNotified());
TESTC(m_rgpListeners[1]->SetCancel(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
//Verify results, should not have been notified FAILEDTODO for the one not interested
TESTC(ResetTimesNotified());
TESTC_(ClearRowPosition(pIRowPosition),DB_E_CANCELED);
TESTC(0 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_FAILEDTODO));
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc General - return E_FAIL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_6()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Set E_FAIL
TESTC(m_rgpListeners[0]->SetError(E_FAIL));
TESTC(m_rgpListeners[1]->SetError(E_FAIL));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc General - return E_OUTOFMEMORY
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_7()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Set E_FAIL
TESTC(m_rgpListeners[0]->SetError(E_OUTOFMEMORY));
TESTC(m_rgpListeners[1]->SetError(E_OUTOFMEMORY));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_8()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Test in all four phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_9()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_10()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//--------------------------------------------------------------------
// @mfunc Sequence - Advise inbetween seperate notifications
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_11()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS*2];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
//Advise all Listeners (again)
TESTC(AdviseAll(&rgCookies[MAX_LISTENERS], pIRowPosition));
//Clear RowPosition
TESTC(ResetTimesNotified());
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(4));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(8));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
UnadviseAll(&rgCookies[MAX_LISTENERS], pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Advise during a notification
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_12()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPos()));
//Indicate this is the Listener to Advise during the Callback
m_rgpListeners[2]->SetAdvise(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO);
//Clear RowPosition
//Listeners advised in the middle should not receive notifications
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//Set RowPosition
TESTC_(SetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
m_rgpListeners[2]->SetUnadvise(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT);
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//Set RowPosition
TESTC_(SetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPos());
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//--------------------------------------------------------------------
// @mfunc Sequence - Unadvise inbetween seperate notification
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_13()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS*2];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Advise all Listeners (again)
TESTC(AdviseAll(&rgCookies[MAX_LISTENERS], pIRowPosition));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(4));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(2, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(8));
//Unadvise inbetween notifications
UnadviseAll(rgCookies, pIRowPosition);
//Clear RowPosition
TESTC(ResetTimesNotified());
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(VerifyTimesNotified(2));
//Set RowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(VerifyTimesNotified(1, DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(VerifyTimesNotified(4));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(&rgCookies[MAX_LISTENERS], pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Sequence - Unadvise during a notification
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_14()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPos()));
//Indicate this is the Listener to Advise during the Callback
m_rgpListeners[2]->SetAdvise(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO);
//Clear RowPosition
//Listeners advised in the middle should not receive notifications
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//Set RowPosition
TESTC_(SetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
m_rgpListeners[2]->SetUnadvise(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT);
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPos()),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_OKTODO));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CLEARED, DBEVENTPHASE_ABOUTTODO));
TESTC(ResetTimesNotified());
//Set RowPosition
TESTC_(SetRowPosition(pIRowPos(), DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_EOF),S_OK);
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[0]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[1]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(2 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_SYNCHAFTER));
TESTC(1 == m_rgpListeners[2]->GetTimesNotified(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(ResetTimesNotified());
CLEANUP:
UnadviseAll(rgCookies, pIRowPos());
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_15()
{
// TO DO: Add your own code here
return TRUE;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc SetRowPosition - Error Cases - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCOnRowPositionChange::Variation_16()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
IRowPosition* pIRowPosition = NULL;
//CreateRowPosition
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Advise all Listeners
TESTC(AdviseAll(rgCookies, pIRowPosition));
//Clear RowPosition
TESTC_(ClearRowPosition(pIRowPosition),S_OK);
//SetRowPosition
TESTC_(SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, DB_NULL_HROW, DBPOSITION_OK),E_INVALIDARG);
TESTC(VerifyFailedTodo(DBREASON_ROWPOSITION_CHANGED, DBEVENTPHASE_ABOUTTODO));
CLEANUP:
UnadviseAll(rgCookies, pIRowPosition);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCOnRowPositionChange::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCConnectionStuff)
//*-----------------------------------------------------------------------
//| Test Case: TCConnectionStuff - Testing all the connection routines
//| Created: 06/26/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCConnectionStuff::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCRowPosition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc General: Container: QI for IID_IConnectionPointContainer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_1()
{
TBEGIN
IConnectionPointContainer* pICPC= NULL;
IUnknown* pIUnknown= NULL;
TESTC_(QI(pIRowPos(), IID_IConnectionPointContainer, (void**)&pICPC),S_OK);
TESTC_(QI(pICPC, IID_IConnectionPointContainer, (void**)&pIUnknown),S_OK);
TESTC(pICPC != NULL && pIUnknown != NULL);
SAFE_RELEASE(pIUnknown);
TESTC_(pICPC->QueryInterface(IID_IUnknown,(void**)&pIUnknown),S_OK);
TESTC(pIUnknown != NULL);
CLEANUP:
SAFE_RELEASE(pIUnknown);
SAFE_RELEASE(pICPC);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Container: AddRef
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_2()
{
TBEGIN
IConnectionPointContainer* pICPC = NULL;
//Get Current RefCount
ULONG ulOrgRefCount = GetRefCount(pIRowPos());
TESTC_(QI(pIRowPos(), IID_IConnectionPointContainer, (void**)&pICPC),S_OK);
TESTC(VerifyRefCounts(GetRefCount(pICPC), ulOrgRefCount+1));
CLEANUP:
SAFE_RELEASE(pICPC);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Container: Release
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_3()
{
TBEGIN
IConnectionPointContainer* pICPC = NULL;
//Get Current RefCount
ULONG ulOrgRefCount = GetRefCount(pIRowPos());
TESTC_(QI(pIRowPos(), IID_IConnectionPointContainer, (void**)&pICPC),S_OK);
TESTC(VerifyRefCounts(GetRefCount(pICPC), ulOrgRefCount+1));
TESTC(VerifyRefCounts(pICPC->Release(), ulOrgRefCount));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Container: FindConnectionPoint for a connection
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_4()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
TESTC_(pICPC()->FindConnectionPoint(IID_IRowPositionChange, &pIConnectionPoint),S_OK);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Container EnumConnectionPoints
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_5()
{
TBEGIN
IEnumConnectionPoints* pIEnum= NULL;
TESTC_(pICPC()->EnumConnectionPoints(&pIEnum),S_OK);
TESTC(pIEnum != NULL);
CLEANUP:
SAFE_RELEASE(pIEnum);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Container: Next should work until there are no more
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_6()
{
TBEGIN
IConnectionPoint* pIConnectionPoint;
IConnectionPoint* pIConnectionPoint2 = INVALID(IConnectionPoint*);
ULONG cFetched = 505; //A random start value.
//Reset
TESTC_(pIEnumCP()->Reset(),S_OK);
//Should only be 1 connectionpoint
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint, &cFetched),S_OK);
TESTC(cFetched == 1 && pIConnectionPoint != NULL);
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint2, &cFetched),S_FALSE);
TESTC(cFetched == 0);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
if(pIConnectionPoint2 != INVALID(IConnectionPoint*))
SAFE_RELEASE(pIConnectionPoint2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Container: Clone
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_7()
{
TBEGIN
IConnectionPoint* pIConnectionPoint = NULL;
IConnectionPoint* pIConnectionPoint2 = NULL;
IEnumConnectionPoints* pIEnumCP2 = NULL;
ULONG cFetched=505;//A random start value.
//Obtain first connectionpoint
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint, &cFetched),S_OK);
TESTC(cFetched == 1);
//Clone
TESTC_(pIEnumCP()->Clone(&pIEnumCP2),S_OK);
TESTC_(pIEnumCP2->Next(1, &pIConnectionPoint2, &cFetched),S_FALSE);
TESTC(cFetched == 0 && pIConnectionPoint2 == NULL);
//Verify actually works though
TESTC_(pIEnumCP2->Reset(),S_OK);
TESTC_(pIEnumCP2->Next(1, &pIConnectionPoint2, &cFetched),S_OK);
TESTC(cFetched == 1 && pIConnectionPoint == pIConnectionPoint2);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
SAFE_RELEASE(pIConnectionPoint2);
SAFE_RELEASE(pIEnumCP2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Container: Reset should go to the beginning
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_8()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
ULONG cFetched=505;//A random start value.
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Next(1,&pIConnectionPoint,&cFetched),S_OK);
TESTC(cFetched == 1);
SAFE_RELEASE(pIConnectionPoint);
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Next(1,&pIConnectionPoint,&cFetched),S_OK);
TESTC(cFetched == 1);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Container: The Second one should still be on the end
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_9()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
IEnumConnectionPoints* pIEnumCP2= NULL;
ULONG cFetched=505;//A random start value.
//Go to the end
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Next(1,&pIConnectionPoint,&cFetched),S_OK);
TESTC(cFetched == 1);
SAFE_RELEASE(pIConnectionPoint);
//Clone
TESTC_(pIEnumCP()->Clone(&pIEnumCP2),S_OK);
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP2->Next(1,&pIConnectionPoint,&cFetched),S_FALSE);
TESTC(cFetched == 0 && pIConnectionPoint == NULL);
CLEANUP:
SAFE_RELEASE(pIEnumCP2);
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Container: Skip should skip one
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_10()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
ULONG cFetched=505;//A random start value.
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Skip(1),S_OK);
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint, &cFetched),S_FALSE);
TESTC(cFetched == 0);
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Skip(ULONG_MAX),S_FALSE);
TESTC_(pIEnumCP()->Next(1,&pIConnectionPoint,&cFetched),S_FALSE);
TESTC(cFetched == 0);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Connections: EnumConnections
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_11()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
CONNECTDATA rgConnData[MAX_LISTENERS];
memset(rgConnData, 0, sizeof(CONNECTDATA)*MAX_LISTENERS);
IEnumConnections* pIEnumConnections = NULL;
ULONG cFetched = 101;
//Advise all listeners
AdviseAll(rgCookies);
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Just quickly sanity check
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, rgConnData, &cFetched),S_OK);
TESTC(cFetched == MAX_LISTENERS);
//Verify CONNECTDATA array
TESTC(VerifyConnectData(MAX_LISTENERS, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
CLEANUP:
UnadviseAll(rgCookies);
FreeConnectData(MAX_LISTENERS, rgConnData);
SAFE_RELEASE(pIEnumConnections);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Connections: Next should work until there are no more
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_12()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
CONNECTDATA rgConnData[MAX_LISTENERS];
memset(rgConnData, 0, sizeof(CONNECTDATA)*MAX_LISTENERS);
IEnumConnections* pIEnumConnections = NULL;
ULONG cFetched = 101;
//Advise all listeners
AdviseAll(rgCookies);
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Obtain connection 1 at a time
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Next(1, &rgConnData[0], &cFetched),S_OK);
TESTC(cFetched == 1);
TESTC(VerifyConnectData(1, &rgConnData[0], m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
TESTC_(pIEnumConnections->Next(1, &rgConnData[1], &cFetched),S_OK);
TESTC(cFetched == 1);
TESTC(VerifyConnectData(1, &rgConnData[1], m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
TESTC_(pIEnumConnections->Next(1, &rgConnData[2], &cFetched),S_OK);
TESTC(cFetched == 1);
TESTC(VerifyConnectData(1, &rgConnData[2], m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
FreeConnectData(MAX_LISTENERS, rgConnData);
//Try to onbtain more than in the list
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, rgConnData,&cFetched),S_FALSE);
TESTC(cFetched == MAX_LISTENERS-3);
CLEANUP:
UnadviseAll(rgCookies);
FreeConnectData(MAX_LISTENERS, rgConnData);
SAFE_RELEASE(pIEnumConnections);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Connections: Clone
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_13()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
CONNECTDATA rgConnData[MAX_LISTENERS];
memset(rgConnData, 0, sizeof(CONNECTDATA)*MAX_LISTENERS);
IEnumConnections* pIEnumConnections = NULL;
IEnumConnections* pIEnumConnections2 = NULL;
ULONG cFetched = 101;
//Advise all listeners
AdviseAll(rgCookies);
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Obtain connection all at a time
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_OK);
TESTC(cFetched == MAX_LISTENERS);
TESTC(VerifyConnectData(MAX_LISTENERS, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
FreeConnectData(MAX_LISTENERS, rgConnData);
//Clone
TESTC_(pIEnumConnections->Clone(&pIEnumConnections2),S_OK);
TESTC_(pIEnumConnections2->Next(1, rgConnData, &cFetched),S_FALSE);
TESTC(cFetched == 0);
//Obtain connection all at a time
TESTC_(pIEnumConnections2->Reset(),S_OK);
TESTC_(pIEnumConnections2->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_OK);
TESTC(cFetched == MAX_LISTENERS);
TESTC(VerifyConnectData(MAX_LISTENERS, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
FreeConnectData(MAX_LISTENERS, rgConnData);
CLEANUP:
UnadviseAll(rgCookies);
FreeConnectData(MAX_LISTENERS, rgConnData);
SAFE_RELEASE(pIEnumConnections);
SAFE_RELEASE(pIEnumConnections2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Conenctions: Reset should go to the beginning
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_14()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
CONNECTDATA rgConnData[MAX_LISTENERS];
memset(rgConnData, 0, sizeof(CONNECTDATA)*MAX_LISTENERS);
IEnumConnections* pIEnumConnections = NULL;
ULONG cFetched = 101;
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Before Advising, should have none
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_FALSE);
TESTC(cFetched == 0);
SAFE_RELEASE(pIEnumConnections);
//Advise all listeners
AdviseAll(rgCookies);
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Obtain connection all at a time
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_OK);
TESTC(cFetched == MAX_LISTENERS);
TESTC(VerifyConnectData(MAX_LISTENERS, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
FreeConnectData(MAX_LISTENERS, rgConnData);
//Reset should start work correctly
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_OK);
TESTC(cFetched == MAX_LISTENERS);
TESTC(VerifyConnectData(MAX_LISTENERS, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
CLEANUP:
UnadviseAll(rgCookies);
FreeConnectData(MAX_LISTENERS, rgConnData);
SAFE_RELEASE(pIEnumConnections);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Connections: Skip should skip one
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_15()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
CONNECTDATA rgConnData[MAX_LISTENERS];
memset(rgConnData, 0, sizeof(CONNECTDATA)*MAX_LISTENERS);
IEnumConnections* pIEnumConnections = NULL;
IEnumConnections* pIEnumConnections2 = NULL;
ULONG cFetched = 101;
//Advise all listeners
AdviseAll(rgCookies);
//Obtain enumerator over listeners (connections)
TESTC_(pICP()->EnumConnections(&pIEnumConnections),S_OK);
//Obtain connection all at a time
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Skip(1),S_OK);
//Obtain the rest
TESTC_(pIEnumConnections->Next(MAX_LISTENERS, &rgConnData[0], &cFetched),S_FALSE);
TESTC(cFetched == MAX_LISTENERS-1);
TESTC(VerifyConnectData(cFetched, rgConnData, m_cListeners, (IUnknown**)m_rgpListeners, rgCookies));
FreeConnectData(cFetched, rgConnData);
//Skip ULONG_MAX
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Skip(ULONG_MAX),S_FALSE);
TESTC_(pIEnumConnections->Next(1, rgConnData, &cFetched),S_FALSE);
TESTC(cFetched == 0);
//Skip none
TESTC_(pIEnumConnections->Reset(),S_OK);
TESTC_(pIEnumConnections->Skip(0),E_INVALIDARG);
CLEANUP:
UnadviseAll(rgCookies);
FreeConnectData(MAX_LISTENERS, rgConnData);
SAFE_RELEASE(pIEnumConnections);
SAFE_RELEASE(pIEnumConnections2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Point: GetConnectionInterface should return succesful
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_16()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
IID iid;
TESTC_(pICPC()->FindConnectionPoint(IID_IRowPositionChange, &pIConnectionPoint),S_OK);
TESTC_(pIConnectionPoint->GetConnectionInterface(&iid),S_OK);
TESTC(iid == IID_IRowPositionChange);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Point: GetConnectionPointContainer should work with a valid pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_17()
{
TBEGIN
IRowPosition* pIRowPosition = NULL;
IConnectionPoint* pIConnectionPoint = NULL;
IConnectionPointContainer* pICPC = NULL;
IConnectionPointContainer* pICPC2 = NULL;
//Create RowPosition Object
TESTC_(CreateRowPosition(pIRowset(), &pIRowPosition),S_OK);
//Obtain the ConnectionPoint...
TESTC_(QI(pIRowPosition, IID_IConnectionPointContainer, (void**)&pICPC),S_OK);
TESTC_(pICPC->FindConnectionPoint(IID_IRowPositionChange, &pIConnectionPoint),S_OK);
//Obtain the container from the ConnectionPoint
TESTC_(pIConnectionPoint->GetConnectionPointContainer(&pICPC2),S_OK);
TESTC(pICPC == pICPC2);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
SAFE_RELEASE(pICPC);
SAFE_RELEASE(pICPC2);
SAFE_RELEASE(pIRowPosition);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc B/NULL: Container: QI for IID_NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_18()
{
IUnknown* pIUnknown= NULL;
TESTC_(QI(pICPC(), IID_NULL, (void**)&pIUnknown),E_NOINTERFACE);
TESTC(pIUnknown == NULL);
CLEANUP:
SAFE_RELEASE(pIUnknown);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Container: FindConnectionPoint for IID_NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_19()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
TESTC_(pICPC()->FindConnectionPoint(IID_NULL, &pIConnectionPoint),CONNECT_E_NOCONNECTION);
TESTC(pIConnectionPoint == NULL);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Container: FindConnectionPoint for ppCP is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_20()
{
TBEGIN
TESTC_(pICPC()->FindConnectionPoint(IID_IRowPositionChange, NULL),E_POINTER);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Enum: Next with a rgpcd NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_21()
{
TBEGIN
ULONG cFetched=505;//A random start value.
TESTC_(pIEnumCP()->Next(1, NULL, &cFetched),E_POINTER);
TESTC(cFetched == 0);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Enum: Skip on the second one should still be at the end
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_22()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
ULONG cFetched=505;//A random start value.
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Skip(1),S_OK);
TESTC_(pIEnumCP()->Skip(1),S_FALSE);
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint, &cFetched),S_FALSE);
TESTC(cFetched == 0 && pIConnectionPoint == NULL);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Container: Enum should fail for a NULL pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_23()
{
TBEGIN
TESTC_(pICPC()->EnumConnectionPoints(NULL),E_POINTER);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Enum: reset twice in a row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_24()
{
TBEGIN
IConnectionPoint* pIConnectionPoint= NULL;
IConnectionPoint* pIConnectionPoint2= NULL;
ULONG cFetched=505;//A random start value.
TESTC_(pIEnumCP()->Reset(),S_OK);
TESTC_(pIEnumCP()->Reset(),S_OK); //DOUBLE RESET
TESTC_(pIEnumCP()->Next(1, &pIConnectionPoint, &cFetched),S_OK);
TESTC(cFetched == 1 && pIConnectionPoint != NULL);
TESTC_(pICPC()->FindConnectionPoint(IID_IRowPositionChange, &pIConnectionPoint2),S_OK);
TESTC(pIConnectionPoint == pIConnectionPoint2);
CLEANUP:
SAFE_RELEASE(pIConnectionPoint);
SAFE_RELEASE(pIConnectionPoint2);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Enum: clone where ppIEnum is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_25()
{
TBEGIN
TESTC_(pIEnumCP()->Clone(NULL),E_POINTER);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Point: GetConectionInterface with pIID NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_26()
{
TBEGIN
TESTC_(pICP()->GetConnectionInterface(NULL),E_POINTER);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Point: GetConectionPointContainer with ppCPC null
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_27()
{
TBEGIN
TESTC_(pICP()->GetConnectionPointContainer(NULL),E_POINTER);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc Point: Unadvise before advising should fail
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_28()
{
TBEGIN
TESTC_(pICP()->Unadvise(PtrToUlong(m_rgpListeners[0])),CONNECT_E_NOCONNECTION);
TESTC_(pICP()->Unadvise(1),CONNECT_E_NOCONNECTION);
TESTC_(pICP()->Unadvise(ULONG_MAX),CONNECT_E_NOCONNECTION);
TESTC_(pICP()->Unadvise(0),CONNECT_E_NOCONNECTION);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Point: advise with pointers NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_29()
{
TBEGIN
ULONG dwCookie1 = 101;
ULONG dwCookie2 = 101;
TESTC_(pICP()->Advise(pIRowset(), &dwCookie1),CONNECT_E_CANNOTCONNECT);
TESTC_(pICP()->Advise(NULL, &dwCookie2),E_POINTER);
TESTC(dwCookie1 == 0);
TESTC(dwCookie2 == 0);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc point: Unadvise with pointers NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCConnectionStuff::Variation_30()
{
TBEGIN
ULONG rgCookies[MAX_LISTENERS];
//Advise all listeners
AdviseAll(rgCookies);
TESTC_(pICP()->Unadvise(0),CONNECT_E_NOCONNECTION);
TESTC_(pICP()->Unadvise(PtrToUlong(m_rgpListeners[0])+1),CONNECT_E_NOCONNECTION);
TESTC_(pICP()->Unadvise(ULONG_MAX),CONNECT_E_NOCONNECTION);
CLEANUP:
UnadviseAll(rgCookies);
TRETURN
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCConnectionStuff::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCRowPosition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCTransactions)
//*-----------------------------------------------------------------------
//| Test Case: TCTransactions - Testing RowPos within transactions
//| Created: 7/6/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCTransactions::Init()
{
if(CTransaction::Init())
{
//register interface to be tested
if(RegisterInterface(ROWSET_INTERFACE, IID_IRowset, 0, NULL))
return TRUE;
}
//Not all providers have to support transactions
//If a required interface, an error would have been posted by VerifyInterface
TEST_PROVIDER(m_pITransactionLocal != NULL);
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc COMMIT - fRetaning == TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCTransactions::Variation_1()
{
DBCOUNTITEM cRowsObtained = 0;
HROW* rghRows = NULL;
IRowPosition* pIRowPosition = NULL;
IRowset* pIRowset = NULL;
HCHAPTER hChapter = NULL;
HROW hRow = NULL;
ULONG ulPosition = NULL;
HRESULT hrExpected = S_OK;
//start a transaction
TESTC(StartTransaction(SELECT_ALLFROMTBL, NULL, 0, NULL));
//get a row handle
TESTC_(m_pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained, &rghRows),S_OK);
//Create RowPosition object
TESTC_(TCRowPosition::CreateRowPosition(m_pIRowset, &pIRowPosition),S_OK);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), S_OK);
//commit the transaction with fRetaining==TRUE
TESTC(GetCommit(TRUE))
if(!m_fCommitPreserve)
hrExpected = E_UNEXPECTED;
//After Commit
CHECK(TCRowPosition::GetRowPosition(pIRowPosition, &hChapter, &hRow, &ulPosition), hrExpected);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), hrExpected);
//Allowed to Call IUnknown methods in Zombie (QueryInterface)
CHECK(TCRowPosition::GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset), S_OK);
CHECK(TCRowPosition::CreateRowPosition(m_pIRowset), S_OK);
// 1. When IRowset::GetNextRows is called row ref count = 1
// 2. When TCRowPosition::SetRowPosition is called, if row position is successfully set, it will
// do an IRowset::ReleaseRows() on the HROW so after the call the ref count for row will still
// be 1.
// 3. TCRowPosition::GetRowPosition returns failure because rowset is in zombie state, so
// ref count for row still remains 1.
// 4. TCRowPosition::ClearRowPosition clears the row handle and calls IRowset::ReleaseRows on the
// row handle decrementing the row handle count to zero and thus releasing the row.
// So, when IRowset::ReleaseRows() is called here, the row handle is already in invalid
// state so expect a failure DB_E_ERRORSOCCURRED instead.
TESTC_(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
PROVIDER_FREE(rghRows);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowset);
//clean up. Expected S_OK.
CleanUpTransaction(S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc COMMIT - fRetaning == FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCTransactions::Variation_2()
{
DBCOUNTITEM cRowsObtained = 0;
HROW* rghRows = NULL;
IRowPosition* pIRowPosition = NULL;
IRowset* pIRowset = NULL;
HCHAPTER hChapter = NULL;
HROW hRow = NULL;
ULONG ulPosition = NULL;
HRESULT hrExpected = S_OK;
//start a transaction
TESTC(StartTransaction(SELECT_ALLFROMTBL, NULL, 0, NULL));
//get a row handle
TESTC_(m_pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained, &rghRows),S_OK);
//Create RowPosition object
TESTC_(TCRowPosition::CreateRowPosition(m_pIRowset, &pIRowPosition),S_OK);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), S_OK);
//commit the transaction with fRetaining==FALSE
TESTC(GetCommit(FALSE))
if(!m_fCommitPreserve)
hrExpected = E_UNEXPECTED;
//After Commit
CHECK(TCRowPosition::GetRowPosition(pIRowPosition, &hChapter, &hRow, &ulPosition), hrExpected);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), hrExpected);
//Allowed to Call IUnknown methods in Zombie (QueryInterface)
CHECK(TCRowPosition::GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset), S_OK);
CHECK(TCRowPosition::CreateRowPosition(m_pIRowset), S_OK);
TESTC_(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
PROVIDER_FREE(rghRows);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowset);
//clean up. Expected S_OK.
CleanUpTransaction(XACT_E_NOTRANSACTION);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc ABORT - fRetaning == TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCTransactions::Variation_3()
{
DBCOUNTITEM cRowsObtained = 0;
HROW* rghRows = NULL;
IRowPosition* pIRowPosition = NULL;
IRowset* pIRowset = NULL;
HCHAPTER hChapter = NULL;
HROW hRow = NULL;
ULONG ulPosition = NULL;
HRESULT hrExpected = S_OK;
//start a transaction
TESTC(StartTransaction(SELECT_ALLFROMTBL, NULL, 0, NULL));
//get a row handle
TESTC_(m_pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained, &rghRows),S_OK);
//Create RowPosition object
TESTC_(TCRowPosition::CreateRowPosition(m_pIRowset, &pIRowPosition),S_OK);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), S_OK);
//Abort the transaction with fRetaining==TRUE
TESTC(GetAbort(TRUE))
if(!m_fAbortPreserve)
hrExpected = E_UNEXPECTED;
//After Abort
CHECK(TCRowPosition::GetRowPosition(pIRowPosition, &hChapter, &hRow, &ulPosition), hrExpected);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), hrExpected);
//Allowed to Call IUnknown methods in Zombie (QueryInterface)
CHECK(TCRowPosition::GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset), S_OK);
CHECK(TCRowPosition::CreateRowPosition(m_pIRowset), S_OK);
TESTC_(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
PROVIDER_FREE(rghRows);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowset);
//clean up. Expected S_OK.
CleanUpTransaction(S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ABORT - fRetaning == FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCTransactions::Variation_4()
{
DBCOUNTITEM cRowsObtained = 0;
HROW* rghRows = NULL;
IRowPosition* pIRowPosition = NULL;
IRowset* pIRowset = NULL;
HCHAPTER hChapter = NULL;
HROW hRow = NULL;
ULONG ulPosition = NULL;
HRESULT hrExpected = S_OK;
//start a transaction
TESTC(StartTransaction(SELECT_ALLFROMTBL, NULL, 0, NULL));
//get a row handle
TESTC_(m_pIRowset->GetNextRows(NULL, 0, 1, &cRowsObtained, &rghRows),S_OK);
//Create RowPosition object
TESTC_(TCRowPosition::CreateRowPosition(m_pIRowset, &pIRowPosition),S_OK);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), S_OK);
//Abort the transaction with fRetaining==FALSE
TESTC(GetAbort(FALSE))
if(!m_fCommitPreserve)
hrExpected = E_UNEXPECTED;
//After Abort
CHECK(TCRowPosition::GetRowPosition(pIRowPosition, &hChapter, &hRow, &ulPosition), hrExpected);
CHECK(TCRowPosition::ClearRowPosition(pIRowPosition), S_OK);
CHECK(TCRowPosition::SetRowPosition(pIRowPosition, DB_NULL_HCHAPTER, rghRows[0], DBPOSITION_OK), hrExpected);
//Allowed to Call IUnknown methods in Zombie (QueryInterface)
CHECK(TCRowPosition::GetRowset(pIRowPosition, IID_IRowset, (IUnknown**)&pIRowset), S_OK);
CHECK(TCRowPosition::CreateRowPosition(m_pIRowset), S_OK);
TESTC_(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
PROVIDER_FREE(rghRows);
SAFE_RELEASE(pIRowPosition);
SAFE_RELEASE(pIRowset);
//clean up. Expected S_OK.
CleanUpTransaction(XACT_E_NOTRANSACTION);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCTransactions::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(CTransaction::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
Reference in New Issue View Git Blame Copy Permalink