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

28132 lines
699 KiB
C++
Raw Permalink Blame History

//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright (C) 1995-2000 Microsoft Corporation
//
// @doc
//
// @module IRNotify.cpp | This module is a general library for interface testing
//
///////////////////////////////////////////////////////////////////
// Includes
//
///////////////////////////////////////////////////////////////////
#define DBINITCONSTANTS // Must be defined to initialize constants in OLEDB.H
#define INITGUID
#include "MODStandard.hpp"
#include "IRNotify.h"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0x7cd27cb8, 0xa1f8, 0x11d0, { 0x94, 0xda, 0x00, 0xc0, 0x4f, 0xb6, 0x6a, 0x50 }};
DECLARE_MODULE_NAME("IRowsetNotify");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("Test IRowsetNotify Interface");
DECLARE_MODULE_VERSION(795921705);
// TCW_WizardVersion(2)
// TCW_Automation(True)
// }} TCW_MODULE_GLOBALS_END
//--------------------------------------------------------------------
// @func Module level initialization routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleInit(CThisTestModule* pThisTestModule)
{
return CommonModuleInit(pThisTestModule, IID_IRowsetNotify, SIZEOF_TABLE, ROWSET_INTERFACE);
}
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule* pThisTestModule)
{
return CommonModuleTerminate(pThisTestModule);
}
///////////////////////////////////////////////////////////////////////////////
// Helper Functions
//
///////////////////////////////////////////////////////////////////////////////
BOOL IsValidEvent(DBREASON eReason, DBEVENTPHASE ePhase)
{
//This check is a little more than just making sure eReason/ePhase
//fall into a valid range. Some reasons only have 1 phase, while others
//have all phases...
//So this comparion is, "is this a valid phase for this reason"...
switch(eReason)
{
//All Phases can occur
case DBREASON_ROWSET_FETCHPOSITIONCHANGE:
case DBREASON_ROWSET_CHANGED:
case DBREASON_COLUMN_SET:
case DBREASON_ROW_DELETE:
case DBREASON_ROW_FIRSTCHANGE:
case DBREASON_ROW_INSERT:
case DBREASON_ROW_RESYNCH:
case DBREASON_ROW_UNDOCHANGE:
case DBREASON_ROW_UNDOINSERT:
case DBREASON_ROW_UNDODELETE:
case DBREASON_ROW_UPDATE:
switch(ePhase)
{
case DBEVENTPHASE_OKTODO:
case DBEVENTPHASE_ABOUTTODO:
case DBEVENTPHASE_SYNCHAFTER:
case DBEVENTPHASE_DIDEVENT:
case DBEVENTPHASE_FAILEDTODO:
return TRUE;
default:
break;
}
//DIDEVENT can occur
case DBREASON_ROWSET_RELEASE:
case DBREASON_COLUMN_RECALCULATED:
case DBREASON_ROW_ACTIVATE:
case DBREASON_ROW_RELEASE:
switch(ePhase)
{
case DBEVENTPHASE_DIDEVENT:
return TRUE;
default:
break;
}
}
return FALSE;
}
REASONTYPE ReasonType(DBREASON eReason)
{
ASSERT(IsValidEvent(eReason));
switch(eReason)
{
//All Phases can occur
case DBREASON_ROWSET_FETCHPOSITIONCHANGE:
case DBREASON_ROWSET_CHANGED:
case DBREASON_ROWSET_RELEASE:
return REASONTYPE_ROWSET;
case DBREASON_COLUMN_SET:
case DBREASON_COLUMN_RECALCULATED:
return REASONTYPE_COLUMN;
case DBREASON_ROW_DELETE:
case DBREASON_ROW_FIRSTCHANGE:
case DBREASON_ROW_INSERT:
case DBREASON_ROW_RESYNCH:
case DBREASON_ROW_UNDOCHANGE:
case DBREASON_ROW_UNDOINSERT:
case DBREASON_ROW_UNDODELETE:
case DBREASON_ROW_UPDATE:
case DBREASON_ROW_ACTIVATE:
case DBREASON_ROW_RELEASE:
return REASONTYPE_ROW;
}
return REASONTYPE_INVALID;
}
BOOL IsMultiPhaseReason(DBREASON eReason)
{
ASSERT(IsValidEvent(eReason));
switch(eReason)
{
//All Single Phase Reasons
case DBREASON_ROWSET_RELEASE:
case DBREASON_COLUMN_RECALCULATED:
case DBREASON_ROW_ACTIVATE:
case DBREASON_ROW_RELEASE:
return FALSE;
}
return TRUE;
}
BOOL DisplayNotification(WCHAR* pwszHeader, DBCOUNTITEM cRows, const HROW rghRows[], DBORDINAL cColumns, DBORDINAL* rgColumns, DBREASON eReason, DBEVENTPHASE ePhase, BOOL fError)
{
//Header
TOUTPUT_(pwszHeader);
//Reason
TOUTPUT_(L" - " << GetReasonDesc(eReason));
//Phase
TOUTPUT_(L" - " << GetPhaseDesc(ePhase));
//cRows
if(cRows)
{
TOUTPUT_(L" - cRows - " << cRows);
TOUTPUT_(L"[");
for(DBCOUNTITEM i=0; i<cRows; i++)
{
if(rghRows)
TOUTPUT_(rghRows[i]);
if(i < cRows-1)
TOUTPUT_(",");
}
TOUTPUT_(L"]");
}
//cColumns
if(cColumns)
{
TOUTPUT_(L" - cColumns - " << cColumns);
TOUTPUT_(L"[");
for(DBORDINAL i=0; i<cColumns; i++)
{
if(rgColumns)
TOUTPUT_(rgColumns[i]);
if(i < cColumns-1)
TOUTPUT_(",");
}
TOUTPUT_(L"]");
}
//End on line
TOUTPUT("");
//Increment Error Count (if an error)
if(fError)
(*(GetModInfo()->GetErrorObject()))++;
return TRUE;
}
BOOL IsSameRow(IUnknown* pIUnkRowset, HROW hRow1, HROW hRow2)
{
TBEGIN
IRowsetIdentity* pIRowsetIdentity = NULL;
if(hRow1 != hRow2)
{
//Obtain the IRowsetIdentity interface
TESTC_(QI(pIUnkRowset, IID_IRowsetIdentity, (void**)&pIRowsetIdentity),S_OK);
//See of these rows are equal...
QTESTC_(pIRowsetIdentity->IsSameRow(hRow1, hRow2),S_OK);
}
CLEANUP:
SAFE_RELEASE(pIRowsetIdentity);
TRETURN
}
///////////////////////////////////////////////////////////////////////////////
// COMMAND
//
///////////////////////////////////////////////////////////////////////////////
COMMAND::COMMAND
(
COMMANDTYPE eCommandType
)
{
m_eCommandType = eCommandType;
m_pvObjectId = NULL;
m_ulCommandLevel = 0;
m_cThreads = 0;
m_eReason = 0;
m_ePhase = 0;
m_cRows = 0;
m_cColumns = 0;
m_rgColumns = NULL;
m_dwOption = 0;
m_hrExpected = S_OK;
m_fCanceled = FALSE;
}
COMMAND::COMMAND
(
COMMANDTYPE eCommandType,
void* pvObjectId,
ULONG ulCommandLevel,
ULONG cThreads,
DBREASON eReason,
DBEVENTPHASE ePhase,
HRESULT hrExpected,
DBCOUNTITEM cRows,
ULONG rgRowIds[],
DBORDINAL cColumns,
ULONG rgColumns[],
DWORD dwOption
)
{
ASSERT(pvObjectId);
m_pvObjectId = pvObjectId;
m_eCommandType = eCommandType;
m_ulCommandLevel= ulCommandLevel;
m_cThreads = cThreads;
m_eReason = eReason;
m_ePhase = ePhase;
m_cRows = cRows;
memset(m_rgRowIds, 0, MAX_ROW_COUNT * sizeof(DBCOUNTITEM));
memset(m_rghRows, 0, MAX_ROW_COUNT * sizeof(HROW));
DBCOUNTITEM sum = 0;
DBCOUNTITEM i = 0;
for(i=0; i<cRows; i++)
{
m_rgRowIds[i] = rgRowIds[i];
sum = sum + rgRowIds[i];
}
for(i=cRows; i<MAX_ROW_COUNT; i++)
{
m_rgRowIds[i] = sum + i-cRows+1;
}
m_cColumns = cColumns;
SAFE_ALLOC(m_rgColumns, DBORDINAL, cColumns);
memset(m_rgColumns, 0, (size_t)(cColumns*sizeof(DBORDINAL)));
for(i=0; i<cColumns; i++)
m_rgColumns[i] = rgColumns[i];
m_dwOption = dwOption;
m_hrExpected = hrExpected;
m_fCanceled = FALSE;
CLEANUP:
;
}
COMMAND::~COMMAND()
{
SAFE_FREE(m_rgColumns);
}
BOOL COMMAND::DisplayCommand()
{
TOUTPUT_("Unreached Command - ");
switch(m_eCommandType)
{
case RETURN_ACCEPT: TOUTPUT_("RETURN_ACCEPT"); break;
case RETURN_VETO: TOUTPUT_("RETURN_VETO"); break;
case RETURN_EFAIL: TOUTPUT_("RETURN_EFAIL"); break;
case RETURN_EOUTOFMEMORY: TOUTPUT_("RETURN_EOUTOFMEMORY"); break;
case RETURN_EINVALIDARG: TOUTPUT_("RETURN_EINVALIDARG"); break;
case RETURN_UNWANTEDREASON: TOUTPUT_("RETURN_UNWANTEDREASON"); break;
case RETURN_UNWANTEDPHASE: TOUTPUT_("RETURN_UNWANTEDPHASE"); break;
case RETURN_ADVISE: TOUTPUT_("RETURN_ADVISE"); break;
case RETURN_UNADVISE: TOUTPUT_("RETURN_UNADVISE"); break;
default:
TOUTPUT_("OLEDB Method ");
break;
}
//Display the rest of the info
return DisplayNotification(NULL, m_cRows, m_rghRows, m_cColumns, m_rgColumns, m_eReason, m_ePhase, FALSE);
}
///////////////////////////////////////////////////////////////////////////////
// ROWINFO
//
///////////////////////////////////////////////////////////////////////////////
ROWINFO::ROWINFO(HROW hRow)
{
m_eRowStatus = ROWSTATUS_NOCHANGE;
m_hRow = hRow;
m_cRefCount = 1;
m_cbBookmark = 0;
m_pBookmark = NULL;
m_fFirstChange = TRUE;
m_pNewData = NULL;
m_pOrgData = NULL;
}
ROWINFO::~ROWINFO()
{
PROVIDER_FREE(m_pBookmark);
PROVIDER_FREE(m_pNewData);
PROVIDER_FREE(m_pOrgData);
}
///////////////////////////////////////////////////////////////////////////////
// EXPECT (Constructor)
//
///////////////////////////////////////////////////////////////////////////////
EXPECT::EXPECT(CImpIListener* pListener, IRowset* pIRowset, DBCOUNTITEM cRows, HROW* rghRows, DBORDINAL cColumns, DBORDINAL rgColumns[], DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(pListener);
ASSERT(pIRowset);
DBCOUNTITEM i = 0;
m_pListener = pListener;
m_pIRowset = pIRowset;
//Rows
m_cRows = cRows;
memset(m_rghRows, 0, sizeof(m_rghRows));
for(i=0; i<cRows; i++)
m_rghRows[i] = rghRows[i];
//Columns
m_cColumns = cColumns;
SAFE_ALLOC(m_rgColumns, DBORDINAL, cColumns);
memset(m_rgColumns, 0, (size_t)(cColumns*sizeof(DBORDINAL)));
for(i=0; i<cColumns; i++)
m_rgColumns[i] = rgColumns[i];
//Notification
m_eReason = eReason;
m_ePhase = ePhase;
m_ulTimesNotified = 0;
m_fCanceled = FALSE;
m_bCompleted = FALSE;
m_fOptional = FALSE;
CLEANUP:
;
}
///////////////////////////////////////////////////////////////////////////////
// EXPECT (Copy Constructor)
//
///////////////////////////////////////////////////////////////////////////////
EXPECT::EXPECT(const EXPECT& rExpect)
{
m_pListener = rExpect.m_pListener;
m_pIRowset = rExpect.m_pIRowset;
DBCOUNTITEM i = 0;
//Rows
m_cRows = rExpect.m_cRows;
for(i=0; i<rExpect.m_cRows; i++)
m_rghRows[i] = rExpect.m_rghRows[i];
//Columns
m_cColumns = rExpect.m_cColumns;
SAFE_ALLOC(m_rgColumns, DBORDINAL, m_cColumns);
memset(m_rgColumns, 0, (size_t)(m_cColumns*sizeof(DBORDINAL)));
for(i=0; i<rExpect.m_cColumns; i++)
m_rgColumns[i] = rExpect.m_rgColumns[i];
//Notification
m_eReason = rExpect.m_eReason;
m_ePhase = rExpect.m_ePhase;
m_ulTimesNotified = rExpect.m_ulTimesNotified;
m_fCanceled = rExpect.m_fCanceled;
m_bCompleted = rExpect.m_bCompleted;
m_fOptional = rExpect.m_fOptional;
CLEANUP:
;
}
EXPECT::~EXPECT()
{
SAFE_FREE(m_rgColumns);
}
BOOL EXPECT::SetPhase(DBEVENTPHASE ePhase)
{
m_ePhase = ePhase;
return TRUE;
}
BOOL EXPECT::SetNextPhase()
{
if(m_pListener->NextPhase(m_eReason, m_ePhase))
{
SetPhase(m_pListener->NextPhase(m_eReason, m_ePhase));
}
else
{
m_bCompleted = TRUE;
}
return TRUE;
}
BOOL EXPECT::IsEqual(DBEVENTPHASE ePhase)
{
return IsEqual(m_pListener, m_pIRowset, m_cRows, m_rghRows, m_cColumns, m_rgColumns, m_eReason, ePhase);
}
BOOL EXPECT::IsEqual(CImpIListener* pListener, IRowset* pIRowset, DBCOUNTITEM cRows, HROW* rghRows, DBORDINAL cColumns, DBORDINAL rgColumns[], DBREASON eReason, DBEVENTPHASE ePhase)
{
TBEGIN
ASSERT(pListener);
ASSERT(pIRowset);
DBORDINAL i;
//Listener
QTESTC(m_pListener == pListener);
//IRowset
QTESTC(m_pIRowset == pIRowset);
//Rows
QTESTC(m_cRows == cRows);
for(i=0; i<cRows; i++)
QTESTC(IsSameRow(m_pIRowset, m_rghRows[i], rghRows[i]));
//Columns
QTESTC(m_cColumns == cColumns);
for(i=0; i<cColumns; i++)
QTESTC(m_rgColumns[i] == rgColumns[i]);
//Notification
QTESTC(m_eReason == eReason);
QTESTC(m_ePhase == ePhase);
CLEANUP:
TRETURN
}
BOOL EXPECT::VerifyEqual(DBEVENTPHASE ePhase)
{
// return VerifyEqual(m_pListener, m_pIRowset, m_cRows, m_rghRows, m_cColumns, m_rgColumns, m_eReason, ePhase);
if (!IsEqual(ePhase))
{
DisplayNotification(L"Expected: ", m_cRows, m_rghRows, m_cColumns, m_rgColumns, m_eReason, ePhase);
return FALSE;
}
return TRUE;
}
BOOL EXPECT::VerifyEqual(CImpIListener* pListener, IRowset* pIRowset, DBCOUNTITEM cRows, HROW rghRows[], DBORDINAL cColumns, DBORDINAL rgColumns[], DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(pListener);
ASSERT(pIRowset);
if(!IsEqual(pListener, pIRowset, cRows, rghRows, cColumns, rgColumns, eReason, ePhase))
{
DisplayNotification(L"Unexpected: ", cRows, rghRows, cColumns, rgColumns, eReason, ePhase);
return FALSE;
}
return TRUE;
}
BOOL EXPECT::DisplayExpectation(WCHAR* pwszTitle)
{
return DisplayNotification(pwszTitle, m_cRows, m_rghRows, m_cColumns, m_rgColumns, m_eReason, m_ePhase);
}
BOOL EXPECT::VerifyComplete()
{
TBEGIN
if(m_pListener->IsWantedReason(m_eReason))
{
if(!m_pListener->IsWantedPhase(m_eReason, DBEVENTPHASE_DIDEVENT))
{
if(IsMultiPhaseReason(m_eReason) && m_ulTimesNotified==0)
DisplayExpectation();
QTESTC(VerifyEqual(DBEVENTPHASE_DIDEVENT));
}
else
{
//We should have been notified for this reason
//If not we have a problem, display expected notification
//The only exception to the rule is ROW_RELEASE.
//Some providers may not have exact refcounts, or the rows may always
//be active, (row count always 1), so just indicate warning...
//The other exception to the rule is DBREASON_COLUMN_RECALCULATED
//Providers are not required to support notifications for this reason (see MDAC bug 16595)
if(m_eReason == DBREASON_ROW_RELEASE)
{
if(m_ulTimesNotified == 0 || !m_bCompleted)
TWARNING(L"ROW_RELEASE never called, Row RefCounts may not be exact...");
QTESTC(VerifyEqual(DBEVENTPHASE_DIDEVENT));
}
else if (m_eReason == DBREASON_COLUMN_RECALCULATED)
{ if(m_ulTimesNotified == 0 || !m_bCompleted)
TWARNING(L"Did not receive notifications for DBREASON_COLUMN_RECALCULATED ...");
QTESTC(VerifyEqual(DBEVENTPHASE_DIDEVENT));
}
else if (m_eReason == DBREASON_ROW_ACTIVATE)
{ if(m_ulTimesNotified == 0)
{
DBCOUNTITEM cRowsExpected = 0;
for (DBCOUNTITEM i=0; i<m_cRows; i++)
if (m_rghRows[i] == DB_NULL_HROW)
cRowsExpected++;
if(cRowsExpected)
DisplayExpectation();
}
}
else
{
if(m_ulTimesNotified == 0 || !m_bCompleted)
DisplayExpectation();
QTESTC(VerifyEqual(DBEVENTPHASE_DIDEVENT));
}
}
}
CLEANUP:
TRETURN;
}
BOOL EXPECT::VerifyInComplete()
{
TBEGIN
if(m_ulTimesNotified)
{
QTESTC(VerifyEqual(DBEVENTPHASE_FAILEDTODO));
if(!m_bCompleted)
DisplayExpectation();
}
if(m_ulTimesNotified == 0)
{
if(m_bCompleted)
DisplayExpectation();
if(IsMultiPhaseReason(m_eReason))
{
QTESTC(VerifyEqual(DBEVENTPHASE_OKTODO));
}
else
{
QTESTC(VerifyEqual(DBEVENTPHASE_DIDEVENT));
}
}
CLEANUP:
TRETURN;
}
///////////////////////////////////////////////////////////////////////////////
// CRowsetObj
//
///////////////////////////////////////////////////////////////////////////////
CRowsetObj::CRowsetObj()
{
InitializeCriticalSection(&m_DataCriticalSection);
m_cRowsetRef = 0;
m_ulNextFetchPos = 0;
m_fTableAltered = FALSE;
m_dwRowsetMode = 0;
//Initialize all properties
m_ulSupportedGranularity = 0;
m_ulSupportedPhases = 0;
m_bReentrantEvents = TRUE;
m_bQuickRestart = TRUE;
//SetData(Updatable) Accessor and bindings.
m_cUpBindings = 0;
m_rgUpBindings = NULL;
m_hUpAccessor = NULL;
memset(m_rgCancelableEvents, 0, sizeof(m_rgCancelableEvents));
}
CRowsetObj::~CRowsetObj()
{
//SetData(Updatable) Accessor and bindings.
FreeAccessorBindings(m_cUpBindings, m_rgUpBindings);
ReleaseAccessor(m_hUpAccessor);
DeleteCriticalSection(&m_DataCriticalSection);
DestroyRowData();
}
BOOL CRowsetObj::IsBufferedMode()
{
return (m_dwRowsetMode & CHANGE_BUFFERRED);
}
HRESULT CRowsetObj::CreateRowset(ROWSET_MODE dwRowsetMode)
{
HRESULT hr = S_OK;
m_dwRowsetMode = dwRowsetMode;
//Query for table, default: Select * from table
EQUERY eQuery = USE_SUPPORTED_SELECT_ALLFROMTBL;
//Set required properties
TESTC(SetProperty(DBPROP_CANHOLDROWS));
TESTC(SetProperty(DBPROP_IConnectionPointContainer));
TESTC(SetProperty(DBPROP_IRowsetIdentity));
//EMPTY_ROWSET
if(dwRowsetMode & EMPTY_ROWSET)
eQuery = SELECT_EMPTYROWSET;
//ROWSETSCROLL_ROWSET
if(dwRowsetMode & ROWSETSCROLL_ROWSET)
TESTC(SetProperty(DBPROP_IRowsetScroll));
//ROWSETINDEX_ROWSET
if(dwRowsetMode & ROWSETINDEX_ROWSET)
TESTC(SetProperty(DBPROP_IRowsetIndex));
//ROWSETLOCATE_ROWSET
if(dwRowsetMode & ROWSETLOCATE_ROWSET)
TESTC(SetProperty(DBPROP_IRowsetLocate));
//SCROLLBACKWARDS
if(dwRowsetMode & SCROLLBACKWARDS)
TESTC(SetProperty(DBPROP_CANSCROLLBACKWARDS));
//FETCHBACKWARDS
if(dwRowsetMode & FETCHBACKWARDS)
TESTC(SetProperty(DBPROP_CANFETCHBACKWARDS));
//RESYNCH_ROWSET
if(dwRowsetMode & RESYNCH_ROWSET)
TESTC(SetProperty(DBPROP_IRowsetResynch));
//REFRESH_ROWSET
if(dwRowsetMode & REFRESH_ROWSET)
TESTC(SetProperty(DBPROP_IRowsetRefresh));
//CHANGE_IMMEDIATE
if(dwRowsetMode & CHANGE_IMMEDIATE)
TESTC(SetProperty(DBPROP_IRowsetChange));
//CHANGE_BUFFERRED
if(dwRowsetMode & CHANGE_BUFFERRED)
{
TESTC(SetProperty(DBPROP_IRowsetChange));
TESTC(SetProperty(DBPROP_IRowsetUpdate));
}
//CHANGE_QBU
if(dwRowsetMode & CHANGE_QBU)
{
TESTC(SetProperty(DBPROP_IRowsetChange));
TESTC(SetProperty(KAGPROP_QUERYBASEDUPDATES, DBPROPSET_PROVIDERROWSET));
}
//COMPUTED_COLUMNS
if((dwRowsetMode & COMPUTED_COLUMNS) || (dwRowsetMode & COMPUTED_COLUMNS_INCLUDE))
eQuery = SELECT_COMPUTEDCOLLIST;
//delegate to the CRowset object
if(dwRowsetMode & COMPUTED_COLUMNS_INCLUDE)
//Need to use ALL_COLS_BOUND to get the computed column. CreateRowset() uses UPDATEABLE_COLS_BOUND by defalt
hr = CRowset::CreateRowset(eQuery, IID_IRowset, NULL, DBACCESSOR_ROWDATA, DBPART_ALL, ALL_COLS_BOUND);
else
hr = CRowset::CreateRowset(eQuery);
//Other setup items...
if(hr==S_OK)
{
//Now get the Notification Properties
GetNotificationProperties();
//We need to obtain bindings for all the updatable(non-index) columns
//if we are creating a rowset with IRowsetChange. We do this ahead of time so we know
//exactly which columns to expect notifications from when SetData(OnFieldChange) is called.
if (dwRowsetMode & COMPUTED_COLUMNS_INCLUDE)
{
//We need the only column - cumputed column and
//acording to SELECT_COMPUTEDCOLLIST it should be the last one
DB_LORDINAL rgColsToBind[1];
rgColsToBind[0] = m_rgBinding[m_cBindings-1].iOrdinal;
TESTC_(hr = GetAccessorAndBindings(pIRowset(), DBACCESSOR_ROWDATA, &m_hUpAccessor,
&m_rgUpBindings, &m_cUpBindings, NULL, DBPART_ALL, USE_COLS_TO_BIND_ARRAY,
FORWARD, NO_COLS_BY_REF, NULL, NULL, NULL, DBTYPE_EMPTY, 1, rgColsToBind,
NULL, NO_COLS_OWNED_BY_PROV, DBPARAMIO_NOTPARAM, NO_BLOB_COLS),S_OK);
}
else
TESTC_(hr = GetAccessorAndBindings(pIRowset(), DBACCESSOR_ROWDATA, &m_hUpAccessor,
&m_rgUpBindings, &m_cUpBindings, NULL, DBPART_ALL, UPDATEABLE_NONINDEX_COLS_BOUND,
FORWARD, NO_COLS_BY_REF, NULL, NULL, NULL, DBTYPE_EMPTY, 0, NULL,
NULL, NO_COLS_OWNED_BY_PROV, DBPARAMIO_NOTPARAM, NO_BLOB_COLS),S_OK);
}
CLEANUP:
return hr;
}
ULONG CRowsetObj::AddRefRowset()
{
//Keep track how many extra references we have put on the rowset
//Mainly used to AddRef -> Release testing making sure no notifications
m_cRowsetRef++;
//AddRef the rowset so it doesn't fire a notification
pIRowset()->AddRef();
return m_cRowsetRef;
}
ULONG CRowsetObj::ReleaseRowset()
{
if(m_cRowsetRef)
{
m_cRowsetRef--;
pIRowset()->Release();
return m_cRowsetRef;
}
return m_cRowsetRef;
}
BOOL CRowsetObj::GetReentrantEvents()
{
return m_bReentrantEvents;
}
BOOL CRowsetObj::IsQuickRestart()
{
return m_bQuickRestart;
}
ULONG_PTR CRowsetObj::GetGranularity()
{
return m_ulSupportedGranularity;
}
ULONG_PTR CRowsetObj::GetSupportedPhases()
{
return m_ulSupportedPhases;
}
BOOL CRowsetObj::IsSupportedPhase(DBEVENTPHASE ePhase)
{
ASSERT(IsValidEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, ePhase));
switch(ePhase)
{
case DBEVENTPHASE_OKTODO:
return ((m_ulSupportedPhases & DBPROPVAL_NP_OKTODO) != 0);
case DBEVENTPHASE_ABOUTTODO:
return ((m_ulSupportedPhases & DBPROPVAL_NP_ABOUTTODO) != 0);
case DBEVENTPHASE_SYNCHAFTER:
return ((m_ulSupportedPhases & DBPROPVAL_NP_SYNCHAFTER) != 0);
case DBEVENTPHASE_DIDEVENT:
return ((m_ulSupportedPhases & DBPROPVAL_NP_DIDEVENT) != 0);
case DBEVENTPHASE_FAILEDTODO:
return ((m_ulSupportedPhases & DBPROPVAL_NP_FAILEDTODO) != 0);
}
return FALSE;
}
BOOL CRowsetObj::GetNotificationProperties()
{
TBEGIN
//Initialize all property values, incase some are not supported
m_ulSupportedGranularity = DBPROPVAL_NT_SINGLEROW;
m_ulSupportedPhases = DBPROPVAL_NP_FAILEDTODO | DBPROPVAL_NP_DIDEVENT;
m_bReentrantEvents = TRUE;
m_bQuickRestart = TRUE;
VARIANT_BOOL bValue = VARIANT_TRUE;
//DBPROP_NOTIFICATIONGRANULARITY
if(SupportedProperty(DBPROP_NOTIFICATIONGRANULARITY, DBPROPSET_ROWSET))
TCHECK(GetProperty(DBPROP_NOTIFICATIONGRANULARITY, DBPROPSET_ROWSET, &m_ulSupportedGranularity),TRUE);
//DBPROP_NOTIFICATIONPHASES
if(SupportedProperty(DBPROP_NOTIFICATIONPHASES, DBPROPSET_ROWSET))
TCHECK(GetProperty(DBPROP_NOTIFICATIONPHASES, DBPROPSET_ROWSET, &m_ulSupportedPhases),TRUE);
//DBPROP_REENTRANTEVENTS
if(SupportedProperty(DBPROP_REENTRANTEVENTS, DBPROPSET_ROWSET))
TCHECK(GetProperty(DBPROP_REENTRANTEVENTS, DBPROPSET_ROWSET, &bValue),TRUE);
m_bReentrantEvents = ((bValue==VARIANT_TRUE) ? TRUE : FALSE);
//DBPROP_QUICKRESTART
if(SupportedProperty(DBPROP_QUICKRESTART, DBPROPSET_ROWSET))
TCHECK(GetProperty(DBPROP_QUICKRESTART, DBPROPSET_ROWSET, &bValue),TRUE);
m_bQuickRestart = ((bValue==VARIANT_TRUE) ? TRUE : FALSE);
//DBPROP_NOTIFY* Cancelable Events
GetProperty(DBPROP_NOTIFYROWSETFETCHPOSITIONCHANGE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROWSET_FETCHPOSITIONCHANGE]);
GetProperty(DBPROP_NOTIFYROWSETRELEASE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROWSET_RELEASE]);
GetProperty(DBPROP_NOTIFYROWSETCHANGED, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROWSET_CHANGED]);
GetProperty(DBPROP_NOTIFYCOLUMNSET, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_COLUMN_SET]);
GetProperty(DBPROP_NOTIFYROWDELETE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_DELETE]);
GetProperty(DBPROP_NOTIFYROWFIRSTCHANGE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_FIRSTCHANGE]);
GetProperty(DBPROP_NOTIFYROWINSERT, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_INSERT]);
GetProperty(DBPROP_NOTIFYROWRESYNCH, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_RESYNCH]);
GetProperty(DBPROP_NOTIFYROWUNDOCHANGE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_UNDOCHANGE]);
GetProperty(DBPROP_NOTIFYROWUNDOINSERT, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_UNDOINSERT]);
GetProperty(DBPROP_NOTIFYROWUNDODELETE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_UNDODELETE]);
GetProperty(DBPROP_NOTIFYROWUPDATE, DBPROPSET_ROWSET, &m_rgCancelableEvents[DBREASON_ROW_UPDATE]);
TRETURN;
}
BOOL CRowsetObj::IsCancelableEvent(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(IsValidEvent(eReason, ePhase));
switch(ePhase)
{
case DBEVENTPHASE_OKTODO:
return ((m_rgCancelableEvents[eReason] & DBPROPVAL_NP_OKTODO) != 0);
case DBEVENTPHASE_ABOUTTODO:
return ((m_rgCancelableEvents[eReason] & DBPROPVAL_NP_ABOUTTODO) != 0);
case DBEVENTPHASE_SYNCHAFTER:
return ((m_rgCancelableEvents[eReason] & DBPROPVAL_NP_SYNCHAFTER) != 0);
}
return FALSE;
}
HRESULT CRowsetObj::SetData(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
void* pMakeData = NULL;
IRowsetChange* pIRowsetChange = NULL;
ROWINFO* pRowInfo = GetRowInfo(pCommand->m_rgRowIds[0]);
//Make Data for the row
MakeRowData(&pMakeData, m_hUpAccessor);
//Obtain IRowsetChange interface...
TESTC_(hr = QI(pIRowset(), IID_IRowsetChange, (void**)&pIRowsetChange),S_OK);
//The test will sometime expect BADROWHANDLE since it thinks that previous calls may have veto'd
//an insertion. Some providers don't allow vetos, so the badrowhandle is dependent upon wither
//it was successful or not. If the row is in our cache, then it must have been allowed...
// if(pCommand->m_hrExpected == DB_E_BADROWHANDLE)
// {
// if(pRowInfo && pRowInfo->m_h`Row)
// pCommand->m_hrExpected = S_OK;
// }
//Now finally Modify the row...
//Can return an Error such as DB_E_CANCELED within a listener
switch(pCommand->m_hrExpected)
{
case DB_E_BADACCESSORHANDLE:
hr = pIRowsetChange->SetData(pCommand->m_rghRows[0], DB_NULL_HACCESSOR, pMakeData);
break;
default:
hr = pIRowsetChange->SetData(pCommand->m_rghRows[0], m_hUpAccessor, pMakeData);
break;
};
//If SetData is successful then we can mark this row as having been changed.
if(SUCCEEDED(hr))
{
TESTC(pRowInfo != NULL);
pRowInfo->m_fFirstChange = FALSE;
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
}
CLEANUP:
ReleaseRowData(pMakeData, m_hUpAccessor);
SAFE_RELEASE(pIRowsetChange);
return hr;
}
HRESULT CRowsetObj::Update(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetUpdate* pIRowsetUpdate = NULL;
DBCOUNTITEM cRowsUpdated = 0;
HROW* rghRowsUpdated = NULL;
DBROWSTATUS* rgRowStatus = NULL;
//IRowsetUpdate->Update
TESTC_(hr = pIRowset()->QueryInterface(IID_IRowsetUpdate,(void**)&pIRowsetUpdate),S_OK);
//Can return an error DB_S/DB_E if canceled from within a listener
hr = pIRowsetUpdate->Update(NULL, pCommand->m_cRows, pCommand->m_rghRows, &cRowsUpdated, &rghRowsUpdated, &rgRowStatus);
//If the Update succeeded, then we can clear the RowStatus flags
//only for those rows actually updated
if(SUCCEEDED(hr))
{
//Verify the results first
if(pCommand->m_cRows)
{
TESTC(cRowsUpdated == pCommand->m_cRows);
TESTC(rgRowStatus != NULL);
}
if(pCommand->m_dwOption)
{
TESTC(cRowsUpdated == pCommand->m_dwOption);
TESTC(rgRowStatus != NULL);
}
//dwOptions represent the number of pending rows for the (0,NULL) case...
for(DBCOUNTITEM i=0; i<pCommand->m_cRows || i<pCommand->m_dwOption; i++)
{
ROWINFO* pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]);
if(pRowInfo == NULL)
continue;
//Only update our flags if row was successflly updated
if(rgRowStatus && rgRowStatus[i] != DBROWSTATUS_S_OK)
continue;
//Update of a DeletedRow forces the row to no longer be valid
if(pRowInfo->m_eRowStatus != ROWSTATUS_DELETED)
{
//Save the current Data
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
memmove(pRowInfo->m_pOrgData, pRowInfo->m_pNewData, (size_t) SIZEOF_ONEROW);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Verify Update, actually Updated the Values
TESTC(CompareRowData(pRowInfo->m_pOrgData, pRowInfo->m_pNewData, m_hAccessor));
//Get the Original Data for this row
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetOriginalData(pRowInfo->m_hRow, pRowInfo->m_pOrgData),S_OK);
//Verify OrginalData matches current Data after Update
TESTC(CompareRowData(pRowInfo->m_pOrgData, pRowInfo->m_pNewData, m_hAccessor));
}
//Clear the FirstChange status
pRowInfo->m_fFirstChange = TRUE;
//Clear the ChangeStatus
pRowInfo->m_eRowStatus = ROWSTATUS_NOCHANGE;
}
}
CLEANUP:
SAFE_RELEASE(pIRowsetUpdate);
PROVIDER_FREE(rghRowsUpdated);
PROVIDER_FREE(rgRowStatus);
return hr;
}
HRESULT CRowsetObj::Undo(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetUpdate* pIRowsetUpdate = NULL;
DBCOUNTITEM cRowsUndone = 0;
HROW* rghRowsUndone = NULL;
DBROWSTATUS* rgRowStatus = NULL;
//IRowsetUpdate->Update
TESTC_(hr = pIRowset()->QueryInterface(IID_IRowsetUpdate,(void**)&pIRowsetUpdate),S_OK);
//Can return an error DB_S/DB_E if canceled from within a listener
hr = pIRowsetUpdate->Undo(NULL, pCommand->m_cRows, pCommand->m_rghRows, &cRowsUndone, &rghRowsUndone, &rgRowStatus);
//If the Undo succeeded, then we can clear the UndoStatus flags
if(SUCCEEDED(hr))
{
//Verify the results first
if(pCommand->m_cRows)
{
TESTC(cRowsUndone == pCommand->m_cRows);
TESTC(rgRowStatus != NULL);
}
if(pCommand->m_dwOption)
{
TESTC(cRowsUndone == pCommand->m_dwOption);
TESTC(rgRowStatus != NULL);
}
//dwOptions represent the number of pending rows for the (0,NULL) case...
for(DBCOUNTITEM i=0; i<pCommand->m_cRows || i<pCommand->m_dwOption; i++)
{
ROWINFO* pRowInfo = NULL;
TESTC((pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i])) != NULL);
//Only update our flags if row was successflly undone
if(rgRowStatus && rgRowStatus[i] != DBROWSTATUS_S_OK)
continue;
//Undo of an InsertedRow forces the row to no longer be valid
if(pRowInfo->m_eRowStatus != ROWSTATUS_INSERTED)
{
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Verify Undo, actually undoes the Data
TESTC(CompareRowData(pRowInfo->m_pOrgData, pRowInfo->m_pNewData, m_hAccessor));
}
//Clear the FirstChange status
pRowInfo->m_fFirstChange = TRUE;
//Clear the ChangeStatus
pRowInfo->m_eRowStatus = ROWSTATUS_NOCHANGE;
}
}
CLEANUP:
SAFE_RELEASE(pIRowsetUpdate);
PROVIDER_FREE(rghRowsUndone);
PROVIDER_FREE(rgRowStatus);
return hr;
}
HRESULT CRowsetObj::AddRefRows(COMMAND* pCommand)
{
ASSERT(pCommand);
ROWINFO* pRowInfo = NULL;
ULONG rgRefCounts[MAX_ROW_COUNT];
//IRowset::AddRefRows
HRESULT hr = pIRowset()->AddRefRows(pCommand->m_cRows, pCommand->m_rghRows, rgRefCounts, NULL);
//Increment reference counts
if(SUCCEEDED(hr))
{
for(DBCOUNTITEM i=0; i<pCommand->m_cRows; i++)
if(pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]))
{
//Update the reference count.
pRowInfo->m_cRefCount = rgRefCounts[i];
}
}
return hr;
}
HRESULT CRowsetObj::ReleaseRows(COMMAND* pCommand)
{
ASSERT(pCommand);
ROWINFO* pRowInfo = NULL;
HRESULT hr = S_OK;
ULONG rgRefCounts[MAX_ROW_COUNT];
//IRowset::ReleaseRows
switch(pCommand->m_hrExpected)
{
case E_INVALIDARG:
hr = pIRowset()->ReleaseRows(pCommand->m_cRows, NULL, NULL, NULL, NULL);
break;
default:
hr = pIRowset()->ReleaseRows(pCommand->m_cRows, pCommand->m_rghRows, NULL, rgRefCounts, NULL);
break;
}
//Store reference counts
if(SUCCEEDED(hr))
{
for(DBCOUNTITEM i=0; i<pCommand->m_cRows; i++)
if(pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]))
{
//Update the reference count.
pRowInfo->m_cRefCount = rgRefCounts[i];
}
}
return hr;
}
HRESULT CRowsetObj::InsertRow(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetChange* pIRowsetChange = NULL;
ROWINFO* pRowInfo = NULL;
//Make data for the inserted row
TESTC(m_mapRowInfo.Lookup(pCommand->m_rgRowIds[0], pRowInfo));
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC(MakeRowData(&pRowInfo->m_pOrgData))
//InsertRow
//Can return an error such as DB_E_CANCELED inside a listener
TESTC_(hr = QI(pIRowset(), IID_IRowsetChange, (void**)&pIRowsetChange),S_OK);
switch(pCommand->m_hrExpected)
{
case DB_E_BADACCESSORHANDLE:
hr = pIRowsetChange->InsertRow(NULL, DB_NULL_HACCESSOR, pRowInfo->m_pOrgData, &pCommand->m_rghRows[0]);
break;
default:
hr = pIRowsetChange->InsertRow(NULL, m_hAccessor, pRowInfo->m_pOrgData, &pCommand->m_rghRows[0]);
break;
}
//If successful, we have store the row handle!
if(SUCCEEDED(hr))
{
//Verify row handle
TESTC(pCommand->m_rghRows[0]!=DB_NULL_HROW)
//Set the row handle
//ROWINFO* pRowInfo = NULL;
//TESTC(m_mapRowInfo.Lookup(pCommand->m_rgRowIds[0], pRowInfo));
pRowInfo->m_hRow = pCommand->m_rghRows[0];
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Make sure the newly inserted row matches the original data...
TESTC(CompareRowData(pRowInfo->m_pNewData/*pGetData*/, pRowInfo->m_pOrgData/*pSetData*/, m_hAccessor, TRUE/*fSetData*/));
}
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
return hr;
}
HRESULT CRowsetObj::GetNextRows(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
DBCOUNTITEM cOffset = 0;
DBCOUNTITEM cRows = pCommand->m_cRows;
HROW* rghRows = pCommand->m_rghRows;
DBCOUNTITEM cRowsObtained = 0;
DBCOUNTITEM i;
//GetNextRows
//The Command may want to produce a particualr error condition
switch(pCommand->m_hrExpected)
{
case DB_S_ENDOFROWSET:
{
if (cRows==0)
hr = pIRowset()->GetNextRows(NULL, 0, MAX_ROW_COUNT, &cRowsObtained, &rghRows);
else
hr = pIRowset()->GetNextRows(NULL, 0, cRows, &cRowsObtained, &rghRows);
pCommand->m_cRows = cRowsObtained;
}
break;
case DB_E_BADSTARTPOSITION:
hr = pIRowset()->GetNextRows(NULL, MAX_ROW_COUNT, cRows, &cRowsObtained, &rghRows);
break;
case E_INVALIDARG:
hr = pIRowset()->GetNextRows(NULL, 0, cRows, NULL, NULL);
break;
default:
hr = pIRowset()->GetNextRows(NULL, 0, cRows, &cRowsObtained, &rghRows);
break;
}
//Loop through rows obtained
for(i=0; i<cRowsObtained; i++)
{
ROWINFO* pRowInfo = NULL;
if(m_mapRowInfo.Lookup(pCommand->m_rgRowIds[i],pRowInfo))
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(pCommand->m_rghRows[i]);
//Get the bookmark for this row, if bookmarks are on...
if(m_dwRowsetMode & ROWSETLOCATE_ROWSET)
TESTC_(GetBookmark(pRowInfo->m_hRow, pRowInfo),S_OK);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Save the OrgData for this row
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pOrgData),S_OK);
m_mapRowInfo.SetAt(pCommand->m_rgRowIds[i], pRowInfo);
}
//Increment the NextFetchPosition
if(SUCCEEDED(hr) && cRowsObtained)
m_ulNextFetchPos += (cOffset + cRowsObtained);
CLEANUP:
return hr;
}
HRESULT CRowsetObj::RestartPosition(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
// Provider may require release of existing rows before restarting
// if DBPROP_QUICKRESTART=FALSE even if the provider supports a value of VARIANT_TRUE for DBPROP_CANHOLDROWS
if (!IsQuickRestart())
{
DBCOUNTITEM cRows = 0;
HROW rghRows[MAX_ROW_COUNT];
ROWINFO* pRowInfo = NULL;
ULONG rgRefCounts[MAX_ROW_COUNT];
GetRowsToRelease(MAX_ROW_COUNT, cRows, rghRows);
if (cRows)
{
hr = pIRowset()->ReleaseRows(cRows, rghRows, NULL, rgRefCounts, NULL);
//Store reference counts
if(SUCCEEDED(hr))
{
POSITION pos = m_mapRowInfo.GetStartPosition();
while(pos)
{
DBCOUNTITEM Key = 0;
ROWINFO* pRowInfo = NULL;
m_mapRowInfo.GetNextAssoc(pos, Key, pRowInfo);
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(DB_NULL_HROW);
m_mapRowInfo.SetAt(Key, pRowInfo);
}
}
}
}
//RestartPosition
hr = pIRowset()->RestartPosition(NULL);
//Can return DB_S_COMMANDREEXECUTED
if(hr==DB_S_COMMANDREEXECUTED)
hr = S_OK;
//Reset the rowset values
if(SUCCEEDED(hr))
{
m_ulNextFetchPos = 0;
m_fTableAltered = FALSE;
}
return hr;
}
HRESULT CRowsetObj::GetRowsAt(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetLocate* pIRowsetLocate = NULL;
DBCOUNTITEM cRowsObtained = 0;
DBCOUNTITEM cRows = pCommand->m_cRows;
HROW* rghRows = pCommand->m_rghRows;
DBCOUNTITEM i=0;
//Bookmark for this row should be DBBMK_FIRST or DBBMK_LAST
ULONG Bookmark = pCommand->m_dwOption;
TESTC(Bookmark==DBBMK_FIRST || Bookmark==DBBMK_LAST);
//GetRowsAt
TESTC_(hr = pIRowset()->QueryInterface(IID_IRowsetLocate,(void**)&pIRowsetLocate),S_OK);
//Can return an error if canceled from within a listener
//Standard BMK size is 1 byte for DBBMK_FIRST or DBBMK_LAST
switch(pCommand->m_hrExpected)
{
case DB_E_BADSTARTPOSITION:
hr = pIRowsetLocate->GetRowsAt(NULL, NULL, sizeof(BYTE), (BYTE*)&Bookmark, MAX_ROW_COUNT, cRows, &cRowsObtained, &rghRows);
break;
case DB_S_ENDOFROWSET:
hr = pIRowsetLocate->GetRowsAt(NULL, NULL, sizeof(BYTE), (BYTE*)&Bookmark, 0, MAX_ROW_COUNT, &cRowsObtained, &rghRows);
break;
default:
hr = pIRowsetLocate->GetRowsAt(NULL, NULL, sizeof(BYTE), (BYTE*)&Bookmark, 0, cRows, &cRowsObtained, &rghRows);
break;
}
//Verify results
if(hr==S_OK)
TESTC(cRows == cRowsObtained);
//Loop through rows obtained
for(i=0; i<cRowsObtained; i++)
{
ROWINFO* pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]);
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(pCommand->m_rghRows[i]);
//Get the bookmark for this row
if(m_dwRowsetMode & ROWSETLOCATE_ROWSET)
TESTC_(GetBookmark(pRowInfo->m_hRow, pRowInfo),S_OK);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Save the Data for this row
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pOrgData),S_OK);
m_mapRowInfo.SetAt(pCommand->m_rgRowIds[i], pRowInfo);
}
CLEANUP:
SAFE_RELEASE(pIRowsetLocate);
return hr;
}
HRESULT CRowsetObj::GetRowsAtRatio(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetScroll* pIRowsetScroll = NULL;
DBCOUNTITEM cRows = pCommand->m_cRows;
HROW* rghRows = pCommand->m_rghRows;
ULONG ulRatio = pCommand->m_dwOption;
DBCOUNTITEM cRowsObtained = 0;
DBCOUNTITEM i;
//GetRowsAtRatio
TESTC_(hr = pIRowset()->QueryInterface(IID_IRowsetScroll,(void**)&pIRowsetScroll),S_OK);
//Can return an error if canceled from within a listener
switch(pCommand->m_hrExpected)
{
case DB_S_ENDOFROWSET:
hr = pIRowsetScroll->GetRowsAtRatio(NULL, NULL, 0, ulRatio, MAX_ROW_COUNT, &cRowsObtained, &rghRows);
break;
default:
hr = pIRowsetScroll->GetRowsAtRatio(NULL, NULL, 0, ulRatio, cRows, &cRowsObtained, &rghRows);
break;
}
//Verify results
if(hr==S_OK)
TESTC(cRows == cRowsObtained);
//Loop over rows retrived
for(i=0; i<cRowsObtained; i++)
{
ROWINFO* pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]);
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(pCommand->m_rghRows[i]);
//Get the bookmark for this row
if(m_dwRowsetMode & ROWSETLOCATE_ROWSET)
TESTC_(GetBookmark(pRowInfo->m_hRow, pRowInfo),S_OK);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Save the Data for this row
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pOrgData),S_OK);
m_mapRowInfo.SetAt(pCommand->m_rgRowIds[i],pRowInfo);
}
CLEANUP:
SAFE_RELEASE(pIRowsetScroll);
return hr;
}
HRESULT CRowsetObj::GetRowsByBookmark(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetLocate* pIRowsetLocate = NULL;
DBCOUNTITEM i = 0;
//Need to lookup the bookmark value for these rows
ROWINFO* pRowInfo = NULL;
DBBKMARK rgcbBookmarks[MAX_ROW_COUNT];
const BYTE* rgpBookmarks[MAX_ROW_COUNT];
for(i=0; i<pCommand->m_cRows; i++)
{
if(pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]))
{
rgcbBookmarks[i] = pRowInfo->m_cbBookmark; //Bookmark size
rgpBookmarks[i] = pRowInfo->m_pBookmark;
}
}
//IRowsetLocate
TESTC_(hr = pIRowset()->QueryInterface(IID_IRowsetLocate,(void**)&pIRowsetLocate),S_OK);
switch(pCommand->m_hrExpected)
{
case E_INVALIDARG:
hr = pIRowsetLocate->GetRowsByBookmark(NULL, pCommand->m_cRows, NULL, NULL, pCommand->m_rghRows, NULL);
break;
default:
hr = pIRowsetLocate->GetRowsByBookmark(NULL, pCommand->m_cRows, rgcbBookmarks, rgpBookmarks, pCommand->m_rghRows, NULL);
break;
};
//Loop through rows obtained
for(i=0; i<pCommand->m_cRows; i++)
{
if(SUCCEEDED(hr) && pCommand->m_rghRows[i]!=DB_NULL_HROW)
{
ROWINFO* pRowInfo = NULL;
if(m_mapRowInfo.Lookup(pCommand->m_rgRowIds[i],pRowInfo))
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(pCommand->m_rghRows[i]);
//Get the bookmark for this row, if bookmarks are on...
if(m_dwRowsetMode & ROWSETLOCATE_ROWSET)
TESTC_(GetBookmark(pRowInfo->m_hRow, pRowInfo),S_OK);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//Save the OrgData for this row
PROVIDER_FREE(pRowInfo->m_pOrgData);
pRowInfo->m_pOrgData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pOrgData),S_OK);
m_mapRowInfo.SetAt(pCommand->m_rgRowIds[i], pRowInfo);
}
}
CLEANUP:
SAFE_RELEASE(pIRowsetLocate);
return hr;
}
HRESULT CRowsetObj::DeleteRows(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
IRowsetChange* pIRowsetChange = NULL;
//DeleteRows
TESTC_(hr = QI(pIRowset(), IID_IRowsetChange, (void**)&pIRowsetChange),S_OK);
hr = pIRowsetChange->DeleteRows(NULL, pCommand->m_cRows, pCommand->m_rghRows, NULL);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
return hr;
}
HRESULT CRowsetObj::ResynchRows(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
void* pVisibleData = NULL;
DBROWSTATUS* rgRowStatus = NULL;
//ResynchRows
hr = CRowset::ResynchRows(pCommand->m_cRows, pCommand->m_rghRows, NULL, NULL, &rgRowStatus);
//Loop over rows Resynched
if(SUCCEEDED(hr))
{
for(DBCOUNTITEM i=0; i<pCommand->m_cRows; i++)
{
//Only update our flags if row was successfully resynched
if(rgRowStatus[i] != DBROWSTATUS_S_OK)
continue;
if(pCommand->m_rghRows[i] != DB_NULL_HROW)
{
ROWINFO* pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i]);
SAFE_DELETE(pRowInfo);
pRowInfo = new ROWINFO(pCommand->m_rghRows[i]);
m_mapRowInfo.SetAt(pCommand->m_rgRowIds[i],pRowInfo);
//Get the Data for this row
PROVIDER_FREE(pRowInfo->m_pNewData);
pRowInfo->m_pNewData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetData(pRowInfo->m_hRow, pRowInfo->m_pNewData),S_OK);
//GetVisible Data for this row
PROVIDER_FREE(pVisibleData);
pVisibleData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(GetVisibleData(pRowInfo->m_hRow, pVisibleData),S_OK);
//Verify both Visible and Current Data are equal after Resynch
TESTC(CompareRowData(pRowInfo->m_pNewData, pVisibleData, m_hAccessor));
}
}
}
CLEANUP:
PROVIDER_FREE(pVisibleData);
PROVIDER_FREE(rgRowStatus);
return hr;
}
BOOL CRowsetObj::MapRowIds(COMMAND* pCommand)
{
TBEGIN
ASSERT(pCommand);
DBCOUNTITEM cRows = pCommand->m_cRows;
DBCOUNTITEM* rgRowIds = pCommand->m_rgRowIds;
HROW* rghRows = pCommand->m_rghRows;
ROWINFO* pRowInfo = NULL;
switch (pCommand->m_eCommandType)
{
case INSERTROW:
{ pRowInfo = new ROWINFO(DB_NULL_HROW);
pRowInfo->m_eRowStatus = ROWSTATUS_INSERTED;
m_mapRowInfo.SetAt(rgRowIds[0], pRowInfo);
}
break;
case DELETEROWS:
{ // Set HROW's to delete
for(DBCOUNTITEM i=0; i<cRows; i++)
{
TESTC((pRowInfo = GetRowInfo(rgRowIds[i])) != NULL);
rghRows[i] = pRowInfo->m_hRow;
//Insert -> Deleted row is not change,
//Otherwsie this is considerd a deleted row
if(pRowInfo->m_eRowStatus == ROWSTATUS_INSERTED)
pRowInfo->m_eRowStatus = ROWSTATUS_INVALID;
else
pRowInfo->m_eRowStatus = ROWSTATUS_DELETED;
}
}
break;
case SETDATA:
{
if(pRowInfo = GetRowInfo(rgRowIds[0]))
{
rghRows[0] = pRowInfo->m_hRow;
//This row is now treated as modiifed, unless it is an inserted row.
//If inserted it still is treated as inserted
if(pRowInfo->m_eRowStatus != ROWSTATUS_INSERTED)
pRowInfo->m_eRowStatus = ROWSTATUS_CHANGED;
}
}
break;
case UNDO:
case UPDATE:
case RESYNCHROWS:
{
//Set HROW's to Get
for(DBCOUNTITEM i=0; i<cRows; i++)
{
rghRows[i] = DB_NULL_HROW;
if(pRowInfo = GetRowInfo(rgRowIds[i]))
rghRows[i] = pRowInfo->m_hRow;
}
//If cRows==0, (0,NULL) will "do" all rows with
//pending changes. So loop through all rows
if(cRows==0)
{
DBCOUNTITEM key = 0;
DBCOUNTITEM cRowsPending = 0;
POSITION pos = m_mapRowInfo.GetStartPosition();
while(pos)
{
m_mapRowInfo.GetNextAssoc(pos, key, pRowInfo);
if(pRowInfo && pRowInfo->m_eRowStatus != ROWSTATUS_NOCHANGE)
{
rgRowIds[cRowsPending] = key;
rghRows[cRowsPending] = pRowInfo->m_hRow;
cRowsPending++;
}
}
pCommand->m_dwOption = (DWORD) cRowsPending;
}
}
break;
case REFRESHROWS:
{
//Set HROW's to Get
for(DBCOUNTITEM i=0; i<cRows; i++)
{
rghRows[i] = DB_NULL_HROW;
if(pRowInfo = GetRowInfo(rgRowIds[i]))
rghRows[i] = pRowInfo->m_hRow;
}
//If cRows==0, (0,NULL) will "do" all active
//rows. So loop through all rows
if(cRows==0)
{
DBCOUNTITEM key = 0;
DBCOUNTITEM cRowsActive = 0;
POSITION pos = m_mapRowInfo.GetStartPosition();
while(pos)
{
m_mapRowInfo.GetNextAssoc(pos, key, pRowInfo);
if(pRowInfo && pRowInfo->m_eRowStatus != ROWSTATUS_INSERTED &&
pRowInfo->m_eRowStatus != ROWSTATUS_DELETED)
{
rgRowIds[cRowsActive] = key;
rghRows[cRowsActive] = pRowInfo->m_hRow;
cRowsActive++;
}
}
pCommand->m_dwOption = (ULONG) cRowsActive;
}
}
break;
default:
{
//Set HROW's to Get
for(DBCOUNTITEM i=0; i<cRows; i++)
{
rghRows[i] = DB_NULL_HROW;
if(pRowInfo = GetRowInfo(rgRowIds[i]))
rghRows[i] = pRowInfo->m_hRow;
}
}
break;
}
CLEANUP:
TRETURN;
}
HRESULT CRowsetObj::GetData(HROW hRow, void* pData)
{
ASSERT(hRow != DB_NULL_HROW);
ASSERT(pData);
HRESULT hr = S_OK;
//GetData
TESTC_(pIRowset()->GetData(hRow, m_hAccessor, pData),S_OK);
CLEANUP:
return hr;
}
HRESULT CRowsetObj::GetOriginalData(HROW hRow, void* pData)
{
ASSERT(hRow != DB_NULL_HROW);
ASSERT(pData);
HRESULT hr = S_OK;
IRowsetUpdate* pIRowsetUpdate = NULL;
//Obtain IRowsetUpdate
TESTC_(QI(pIRowset(), IID_IRowsetUpdate, (void**)&pIRowsetUpdate),S_OK);
//GetOriginalData
hr = pIRowsetUpdate->GetOriginalData(hRow, m_hAccessor, pData);
CLEANUP:
SAFE_RELEASE(pIRowsetUpdate);
return hr;
}
HRESULT CRowsetObj::GetVisibleData(HROW hRow, void* pData)
{
ASSERT(hRow != DB_NULL_HROW);
ASSERT(pData);
HRESULT hr = S_OK;
IRowsetResynch* pIRowsetResynch = NULL;
//Obtain IRowsetResynch
TESTC_(QI(pIRowset(), IID_IRowsetResynch, (void**)&pIRowsetResynch),S_OK);
//GetVisibleData
hr = pIRowsetResynch->GetVisibleData(hRow, m_hAccessor, pData);
CLEANUP:
SAFE_RELEASE(pIRowsetResynch);
return hr;
}
HRESULT CRowsetObj::GetLastVisibleData(HROW hRow, void* pData)
{
ASSERT(hRow != DB_NULL_HROW);
ASSERT(pData);
HRESULT hr = S_OK;
IRowsetRefresh* pIRowsetRefresh = NULL;
//Obtain IRowsetRefresh
TESTC_(QI(pIRowset(), IID_IRowsetRefresh, (void**)&pIRowsetRefresh),S_OK);
//RefreshVisibleData
hr = pIRowsetRefresh->GetLastVisibleData(hRow, m_hAccessor, pData);
CLEANUP:
SAFE_RELEASE(pIRowsetRefresh);
return hr;
}
HRESULT CRowsetObj::GetData(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
HRESULT hrExpected = S_OK;
ROWINFO* pRowInfo = NULL;
void* pData = NULL;
//Loop though all specificed rows and make sure GetData returns the correc
//data for this row
for(DBCOUNTITEM i=0; i<pCommand->m_cRows; i++)
{
if (pCommand->m_rghRows[i] != DB_NULL_HROW)
{
//Get the "Current" Data for this row
pData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(pIRowset()->GetData(pCommand->m_rghRows[i], m_hAccessor, pData),S_OK);
//Lookup the Saved data for this row
TESTC((pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i])) != NULL);
//Compare data
TESTC(CompareRowData(pData, pRowInfo->m_pNewData, m_hAccessor));
PROVIDER_FREE(pData);
}
}
CLEANUP:
PROVIDER_FREE(pData);
return hr;
}
HRESULT CRowsetObj::GetOriginalData(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
HRESULT hrExpected = pCommand->m_hrExpected;
ROWINFO* pRowInfo = NULL;
void* pData = NULL;
IRowsetUpdate* pIRowsetUpdate = NULL;
DBCOUNTITEM i=0;
//Obtain IRowsetUpdate interface
TESTC_(hr = QI(pIRowset(), IID_IRowsetUpdate, (void**)&pIRowsetUpdate),S_OK);
//Loop though all rows and make sure GetData returns the correct data
for(i=0; i<pCommand->m_cRows; i++)
{
//Get the "Current" Data for this row
pData = PROVIDER_ALLOC(SIZEOF_ONEROW);
//As can call during notification may receive DB_E_NOTREENTRANT (pCommand->m_hrExpected)
TEST2C_(hr = pIRowsetUpdate->GetOriginalData(pCommand->m_rghRows[i], m_hAccessor, pData), S_OK, hrExpected);
if (hr==S_OK)
{
// if received S_OK for one row should receive it for all
if (i==0) hrExpected = S_OK;
//Lookup the Saved data for this row
TESTC((pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i])) != NULL);
//Compare data
TESTC(CompareRowData(pRowInfo->m_pOrgData, pData, m_hAccessor));
}
PROVIDER_FREE(pData);
}
CLEANUP:
SAFE_RELEASE(pIRowsetUpdate);
PROVIDER_FREE(pData);
return hr;
}
HRESULT CRowsetObj::GetVisibleData(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
HRESULT hrExpected = pCommand->m_hrExpected;
ROWINFO* pRowInfo = NULL;
void* pData = NULL;
IRowsetResynch* pIRowsetResynch = NULL;
DBCOUNTITEM i=0;
//Obtain IRowsetUpdate interface
TESTC_(hr = QI(pIRowset(), IID_IRowsetResynch, (void**)&pIRowsetResynch),S_OK);
//Loop though all rows and make sure GetData returns the correct data
for(i=0; i<pCommand->m_cRows; i++)
{
//Get the "Current" Data for this row
pData = PROVIDER_ALLOC(SIZEOF_ONEROW);
//As can call during notification may receive DB_E_NOTREENTRANT (pCommand->m_hrExpected)
TEST2C_(hr = pIRowsetResynch->GetVisibleData(pCommand->m_rghRows[i], m_hAccessor, pData), S_OK, hrExpected);
if (hr==S_OK)
{
// if received S_OK for one row should receive it for all
if (i==0) hrExpected = S_OK;
//Lookup the Saved data for this row
TESTC((pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i])) != NULL);
//Compare data
TESTC(CompareRowData(pData, pRowInfo->m_pOrgData, m_hAccessor));
}
PROVIDER_FREE(pData);
}
CLEANUP:
SAFE_RELEASE(pIRowsetResynch);
PROVIDER_FREE(pData);
return hr;
}
HRESULT CRowsetObj::GetLastVisibleData(COMMAND* pCommand)
{
ASSERT(pCommand);
HRESULT hr = S_OK;
ROWINFO* pRowInfo = NULL;
void* pData = NULL;
IRowsetRefresh* pIRowsetRefresh = NULL;
DBCOUNTITEM i=0;
//Obtain IRowsetUpdate interface
TESTC_(hr = QI(pIRowset(), IID_IRowsetRefresh, (void**)&pIRowsetRefresh),S_OK);
//Loop though all rows and make sure GetData returns the correct data
for(i=0; i<pCommand->m_cRows; i++)
{
//Get the "Current" Data for this row
pData = PROVIDER_ALLOC(SIZEOF_ONEROW);
TESTC_(pIRowsetRefresh->GetLastVisibleData(pCommand->m_rghRows[i], m_hAccessor, pData),S_OK);
//Lookup the Saved data for this row
TESTC((pRowInfo = GetRowInfo(pCommand->m_rgRowIds[i])) != NULL);
//Compare data
TESTC(CompareRowData(pData, pRowInfo->m_pOrgData, m_hAccessor));
PROVIDER_FREE(pData);
}
CLEANUP:
SAFE_RELEASE(pIRowsetRefresh);
PROVIDER_FREE(pData);
return hr;
}
HRESULT CRowsetObj::AddColumn()
{
ASSERT(g_pTable);
HRESULT hr = S_OK;
//Add a column to the table
WCHAR strColName[80];
CCol cCol;
//Get first column information
g_pTable->GetColInfo(1, cCol);
//Provider Type name may be NULL. If running with an INI File, or
//just the fact that our Privlib addColumn loses all the provider typenames when it regenerates
//the columninfo after an add...
if(cCol.GetProviderTypeName())
swprintf(strColName, L"C%02lu%.4s", GetTotalColumns() + 1, cCol.GetProviderTypeName());
else
swprintf(strColName, L"C%02lu", GetTotalColumns() + 1);
cCol.SetColName(strColName);
// add the column
hr = g_pTable->AddColumn(cCol);
//Indicate the underlying Table has been altered
if(SUCCEEDED(hr))
m_fTableAltered = TRUE;
return hr;
}
HRESULT CRowsetObj::DropColumn()
{
ASSERT(g_pTable);
HRESULT hr = S_OK;
const DBORDINAL nColNum = 1;
//Drop the first column from the table
hr = g_pTable->DropColumn(nColNum);
//Indicate the underlying Table has been altered
if(SUCCEEDED(hr))
m_fTableAltered = TRUE;
return hr;
}
HRESULT CRowsetObj::GetColumnInfo()
{
HRESULT hr = S_OK;
DBORDINAL cColInfo = 0;
DBCOLUMNINFO* rgColInfo = NULL;
WCHAR* pStringBuffer = NULL;
//IColumnsInfo::GetColumnInfo
hr = GetColInfo(&cColInfo, &rgColInfo, &pStringBuffer);
SAFE_FREE(rgColInfo);
SAFE_FREE(pStringBuffer);
return hr;
}
HRESULT CRowsetObj::GetBookmark
(
HROW hRow,
ROWINFO* pRowInfo
)
{
ASSERT(pRowInfo);
HRESULT hr = S_OK;
//GetBookmark
TESTC_(hr = CRowset::GetBookmark(hRow, &pRowInfo->m_cbBookmark, &pRowInfo->m_pBookmark),S_OK);
CLEANUP:
return hr;
}
ROWINFO* CRowsetObj::GetRowInfo(DBCOUNTITEM ulRowId)
{
ROWINFO* pRowInfo = NULL;
m_mapRowInfo.Lookup(ulRowId, pRowInfo);
return pRowInfo;
}
BOOL CRowsetObj::DestroyRowData()
{
POSITION pos = m_mapRowInfo.GetStartPosition();
while(pos)
{
DBCOUNTITEM Key = 0;
ROWINFO* pRowInfo = NULL;
m_mapRowInfo.GetNextAssoc(pos, Key, pRowInfo);
if(pIRowset())
{
HRESULT hr = pIRowset()->ReleaseRows(1, &pRowInfo->m_hRow, NULL, NULL, NULL);
}
SAFE_DELETE(pRowInfo);
}
m_mapRowInfo.RemoveAll();
return TRUE;
}
BOOL CRowsetObj::GetRowsToRelease(DBCOUNTITEM cRows, DBCOUNTITEM &cRowsObtained, HROW *rghRows)
{
ASSERT(rghRows);
cRowsObtained = 0;
POSITION pos = m_mapRowInfo.GetStartPosition();
int i=0;
while(pos && cRowsObtained<cRows)
{
DBCOUNTITEM Key = 0;
ROWINFO* pRowInfo = NULL;
i++;
m_mapRowInfo.GetNextAssoc(pos, Key, pRowInfo);
if(pRowInfo->m_hRow != DB_NULL_HROW && pRowInfo->m_cRefCount)
rghRows[cRowsObtained++] = pRowInfo->m_hRow;
pRowInfo = NULL;
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////
// CImpIListener
//
////////////////////////////////////////////////////////////////////////
CImpIListener::CImpIListener(CExecutionManager* pExecutionManager)
{
ASSERT(pExecutionManager);
m_pExecutionManager = pExecutionManager;
m_cRef = 1;
m_dwCookie = 0;
//Set all WantedEvents to TRUE
memset(&m_rgWantedEvent, TRUE, sizeof(m_rgWantedEvent));
//Set times notified to 0
ResetTimesNotified();
}
CImpIListener::~CImpIListener()
{
ASSERT(m_cRef==0);
}
ULONG CImpIListener::AddRef(void)
{
return ++m_cRef;
}
ULONG CImpIListener::Release(void)
{
ASSERT(m_cRef > 0);
if(--m_cRef)
return m_cRef;
delete this;
return 0;
}
HRESULT CImpIListener::QueryInterface(REFIID riid, void** ppv)
{
if(!ppv)
return E_INVALIDARG;
if(riid == IID_IUnknown)
*ppv = this;
else if(riid == IID_IRowsetNotify)
*ppv = this;
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
((IUnknown*)*ppv)->AddRef();
return S_OK;
}
ULONG CImpIListener::GetTimesNotified(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(eReason <= DBREASON_ALL);
ASSERT(ePhase <= DBEVENTPHASE_ALL);
//Can return the number of times notified for either all reasons / phases
//or just a particular reason / phase
ULONG cTimesNotified = 0;
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
if(iReason == eReason || eReason == DBREASON_ALL)
for(ULONG iPhase=0; iPhase<DBEVENTPHASE_ALL; iPhase++)
if(iPhase == ePhase || ePhase == DBEVENTPHASE_ALL)
cTimesNotified += m_rgTimesNotified[iReason][iPhase];
return cTimesNotified;
}
BOOL CImpIListener::ResetTimesNotified(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(eReason <= DBREASON_ALL);
ASSERT(ePhase <= DBEVENTPHASE_ALL);
//Can Reaset all times notified for either all reasons / phases
//or just a particular reason / phase
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
if(iReason == eReason || eReason == DBREASON_ALL)
for(ULONG iPhase=0; iPhase<DBEVENTPHASE_ALL; iPhase++)
if(iPhase == ePhase || ePhase == DBEVENTPHASE_ALL)
m_rgTimesNotified[iReason][iPhase] = 0;
return TRUE;
}
HRESULT CImpIListener::AcceptOrVeto
(
IRowset* pIRowset,
DBCOUNTITEM cRows,
const HROW rghRows[],
DBORDINAL cColumns,
DBORDINAL rgColumns[],
DBREASON eReason,
DBEVENTPHASE ePhase,
BOOL fCantDeny
)
{
HRESULT hr = S_OK;
EXPECT* pExpect = NULL;
COMMAND* pCommand = NULL;
//Make sure this is a valid Reason/Phase
TESTC(IsValidEvent(eReason, ePhase));
//Record this Notification
m_rgTimesNotified[eReason][ePhase]++;
//Verify this Notification matches the Expectation
while(pExpect = pExpectationsManager()->FindExpectation(this, pIRowset, cRows, (HROW*)rghRows, cColumns, rgColumns, eReason, ePhase, fCantDeny))
{
//Find the Command which corresponds to this Reason/Phase
pCommand = pExecutionManager()->PopCommand(this, eReason, ePhase);
TESTC(pCommand != NULL);
switch(pCommand->m_eCommandType)
{
case RETURN_ACCEPT:
pExpectationsManager()->PushNextExpectation(pExpect);
SAFE_DELETE(pCommand);
return S_OK;
case RETURN_VETO:
if(pExecutionManager()->IsCancelableEvent(eReason, ePhase))
{
TESTC(pExpectationsManager()->PushFalseExpectation(pExpect));
}
else
{
TESTC(pExpectationsManager()->PushNextExpectation(pExpect));
}
SAFE_DELETE(pCommand);
return S_FALSE;
case RETURN_UNWANTEDREASON:
//We no longer want this Reason
//Mark as completed since we might not get any more Notifications
SetUnwantedReason(eReason);
pExpectationsManager()->PushUnwantedReason(this, pIRowset, eReason);
SAFE_DELETE(pCommand);
return DB_S_UNWANTEDREASON;
case RETURN_UNWANTEDPHASE:
//Since this Phase is no longer wanted,
//set the expectation to the next wanted phase...
SetUnwantedPhase(eReason, ePhase);
pExpectationsManager()->PushUnwantedPhase(this, pIRowset, eReason, ePhase);
SAFE_DELETE(pCommand);
return DB_S_UNWANTEDPHASE;
case RETURN_EFAIL:
case RETURN_EOUTOFMEMORY:
case RETURN_EINVALIDARG:
//Errors returned should be treated like S_OK (no VETO)
pExpectationsManager()->PushNextExpectation(pExpect);
switch(pCommand->m_eCommandType)
{
case RETURN_EFAIL:
SAFE_DELETE(pCommand);
return E_FAIL;
case RETURN_EOUTOFMEMORY:
SAFE_DELETE(pCommand);
return E_OUTOFMEMORY;
case RETURN_EINVALIDARG:
SAFE_DELETE(pCommand);
return E_INVALIDARG;
}
break;
case RETURN_ADVISE:
{
//Create a new Listener and add to list
pExpectationsManager()->PushAdviseExpectation(pExpect);
return S_OK;
}
case RETURN_UNADVISE:
{ //Unadvise this listener from the Rowset and remove from list
pExpectationsManager()->PushUnadviseExpectation(pExpect);
return S_OK;
}
default:
{
//Execute the nested Command
QTESTC(pExpectationsManager()->PushNestedExpectation(pCommand));
QTESTC(pExecutionManager()->ExecuteCommand(pCommand));
QTESTC(pExpectationsManager()->PopNestedExpectation(pCommand))
SAFE_DELETE(pCommand);
}
}
}
CLEANUP:
SAFE_DELETE(pCommand);
return hr;
}
HRESULT CImpIListener::OnFieldChange
(
IRowset* pIRowset,
HROW hRow,
DBORDINAL cColumns,
DBORDINAL rgColumns[],
DBREASON eReason,
DBEVENTPHASE ePhase,
BOOL fCantDeny
)
{
//Accept / Veto the change, and do processing
HRESULT hr = AcceptOrVeto(pIRowset, ONE_ROW, &hRow, cColumns, rgColumns, eReason, ePhase, fCantDeny);
//Display Notification is user is interested...
PRVTRACE(L" 0x%08x::OnFieldChange(0x%08x, 0x%08x, %d, 0x%08x, %s, %s, %s) - %s\n", this, pIRowset, hRow, cColumns, rgColumns, GetReasonDesc(eReason), GetPhaseDesc(ePhase), fCantDeny==TRUE ? L"TRUE" : L"FALSE", GetErrorName(hr));
return hr;
}
HRESULT CImpIListener::OnRowChange
(
IRowset* pIRowset,
DBCOUNTITEM cRows,
const HROW rghRows[],
DBREASON eReason,
DBEVENTPHASE ePhase,
BOOL fCantDeny
)
{
//Accept / Veto the change, and do processing
HRESULT hr = AcceptOrVeto(pIRowset, cRows, rghRows, 0, NULL, eReason, ePhase, fCantDeny);
//Display Notification is user is interested...
PRVTRACE(L" 0x%08x::OnRowChange(0x%08x, %d, 0x%08x, %s, %s, %s) - %s\n", this, pIRowset, cRows, rghRows, GetReasonDesc(eReason), GetPhaseDesc(ePhase), fCantDeny==TRUE ? L"TRUE" : L"FALSE", GetErrorName(hr));
return hr;
}
HRESULT CImpIListener::OnRowsetChange
(
IRowset* pIRowset,
DBREASON eReason,
DBEVENTPHASE ePhase,
BOOL fCantDeny
)
{
//Accept / Veto the change, and do processing
HRESULT hr = AcceptOrVeto(pIRowset, 0, NULL, 0, NULL, eReason, ePhase, fCantDeny);
//Display Notification is user is interested...
PRVTRACE(L" 0x%08x::OnRowsetChange(0x%08x, %s, %s, %s) - %s\n", this, pIRowset, GetReasonDesc(eReason), GetPhaseDesc(ePhase), fCantDeny==TRUE ? L"TRUE" : L"FALSE", GetErrorName(hr));
return hr;
}
HRESULT CImpIListener::Advise(IRowset* pIRowset)
{
ASSERT(pIRowset);
ASSERT(m_dwCookie == 0); //Implementation only suited for 1 advise per listener
//We can't just use m_pIRowset, since we could Advise / Connect this listener
//to other rowsets besides just the one we wer created with
//But if no rowset* is passed in, we'll use the current one
IConnectionPoint* pICP = NULL;
IConnectionPointContainer* pICPC = NULL;
HRESULT hr = S_OK;
//Obtain the connection point container
TESTC_(hr = pIRowset->QueryInterface(IID_IConnectionPointContainer,(void**)&pICPC),S_OK)
TESTC(pICPC != NULL);
//Obtain the IRowsetNotify connection point
TESTC_(hr = pICPC->FindConnectionPoint(IID_IRowsetNotify,&pICP),S_OK)
TESTC(pICP != NULL);
//Now we can advise the connection
TESTC_(hr = pICP->Advise(this, &m_dwCookie),S_OK)
CLEANUP:
SAFE_RELEASE(pICP);
SAFE_RELEASE(pICPC);
return hr;
}
HRESULT CImpIListener::Unadvise(IRowset* pIRowset)
{
ASSERT(pIRowset);
ASSERT(m_dwCookie != 0);
//We can't just use m_pIRowset, since we could Advise / Connect this listener
//to other rowsets besides just the one we were created with
//But if no rowset* is passed in, we'll use the current one
IConnectionPoint* pICP = NULL;
IConnectionPointContainer* pICPC = NULL;
HRESULT hr = S_OK;
//Obtain the connection point container
TESTC_(hr = pIRowset->QueryInterface(IID_IConnectionPointContainer,(void**)&pICPC),S_OK)
TESTC(pICPC != NULL);
//Obtain the IRowsetNotify connection point
TESTC_(hr = pICPC->FindConnectionPoint(IID_IRowsetNotify,&pICP),S_OK)
TESTC(pICP != NULL);
//Now we can advise the connection
TESTC_(hr = pICP->Unadvise(m_dwCookie),S_OK)
//Set Cookie back to 0
m_dwCookie = 0;
CLEANUP:
SAFE_RELEASE(pICP);
SAFE_RELEASE(pICPC);
return hr;
}
BOOL CImpIListener::IsWantedReason(DBREASON eReason)
{
ASSERT(IsValidEvent(eReason));
//Find the Reason index
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
{
if(iReason == eReason)
{
//If any of the phases for this reason are on (TRUE)
//then this is a "wanted" reason
for(ULONG iPhase=0; iPhase<DBEVENTPHASE_ALL; iPhase++)
if(m_rgWantedEvent[iReason][iPhase])
return TRUE;
}
}
return FALSE;
}
BOOL CImpIListener::IsWantedPhase(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(IsValidEvent(eReason, ePhase));
//Find the Reason index
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
{
if(iReason == eReason)
{
if(m_rgWantedEvent[iReason][ePhase])
return TRUE;
}
}
return FALSE;
}
BOOL CImpIListener::SetUnwantedReason(DBREASON eReason)
{
ASSERT(IsValidEvent(eReason));
//Turn off all phases for this reason
//Which will indicate this reason is not needed for any phase
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
{
if(iReason == eReason)
{
for(ULONG iPhase=0; iPhase<DBEVENTPHASE_ALL; iPhase++)
m_rgWantedEvent[iReason][iPhase] = FALSE;
}
}
return TRUE;
}
BOOL CImpIListener::SetUnwantedPhase(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(IsValidEvent(eReason, ePhase));
//Turn off the indicated phases for this reason
for(ULONG iReason=0; iReason<DBREASON_ALL; iReason++)
{
if(iReason == eReason)
m_rgWantedEvent[iReason][ePhase] = FALSE;
}
return TRUE;
}
DBEVENTPHASE CImpIListener::NextPhase(DBREASON eReason, DBEVENTPHASE ePhase)
{
ASSERT(IsValidEvent(eReason, ePhase));
switch(eReason)
{
//All Phases can occur
case DBREASON_ROWSET_FETCHPOSITIONCHANGE:
case DBREASON_ROWSET_CHANGED:
case DBREASON_COLUMN_SET:
case DBREASON_ROW_DELETE:
case DBREASON_ROW_FIRSTCHANGE:
case DBREASON_ROW_INSERT:
case DBREASON_ROW_RESYNCH:
case DBREASON_ROW_UNDOCHANGE:
case DBREASON_ROW_UNDOINSERT:
case DBREASON_ROW_UNDODELETE:
case DBREASON_ROW_UPDATE:
switch(ePhase)
{
//This setup will return whatever the next phase expected
//Depending upon which phases the Provider supports..
//The cases will just "fall" through to the next step if a
//phase is not supported...
case DBEVENTPHASE_OKTODO:
if(pExecutionManager()->pCRowsetObj()->IsSupportedPhase(DBEVENTPHASE_ABOUTTODO))
return DBEVENTPHASE_ABOUTTODO;
case DBEVENTPHASE_ABOUTTODO:
if(pExecutionManager()->pCRowsetObj()->IsSupportedPhase(DBEVENTPHASE_SYNCHAFTER))
return DBEVENTPHASE_SYNCHAFTER;
case DBEVENTPHASE_SYNCHAFTER:
if(pExecutionManager()->pCRowsetObj()->IsSupportedPhase(DBEVENTPHASE_DIDEVENT))
return DBEVENTPHASE_DIDEVENT;
}
}
return 0;
}
CExecutionManager* CImpIListener::pExecutionManager()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager;
}
CExpectationsManager* CImpIListener::pExpectationsManager()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager->pExpectationsManager();
}
///////////////////////////////////////////////////////////////////////////////
// CControl
//
///////////////////////////////////////////////////////////////////////////////
CControl::CControl(CExecutionManager* pExecutionManager)
{
ASSERT(pExecutionManager);
m_pExecutionManager = pExecutionManager;
//Create a Suspended Thread
m_hThread = CreateThread(NULL, 1024, CControl::ThreadFunction, this, CREATE_SUSPENDED, &m_dwThreadId);
TESTC(m_hThread != 0);
CLEANUP:
return;
}
CControl::~CControl()
{
CloseHandle(m_hThread);
}
DWORD CControl::GetThreadId()
{
return m_dwThreadId;
}
DWORD CControl::WaitForThread()
{
return WaitForThreads(1, &m_hThread);
}
ULONG CControl::Execute()
{
return ResumeThread(m_hThread);
}
ULONG WINAPI CControl::ThreadFunction(void* pv)
{
THREAD_BEGIN
CControl* pThis = (CControl*)pv;
ASSERT(pThis);
CExecutionManager* pExecutionManager = pThis->pExecutionManager();
CExpectationsManager* pExpectationsManager = pThis->pExpectationsManager();
ASSERT(pExecutionManager && pExpectationsManager);
HRESULT hr = S_OK;
//This is a Thread function, it must be a static function, taking void* and
//returning ULONG. Since it must be static, there is no "this" pointer,
//so we pass in the this pointer to the object...
//While there are Commands to be executed
while(!pExecutionManager->IsCommandListEmpty())
{
//On the list are "Listener" Commands and "Control" Commands
//Pop off a "Control" Command, if there is not one left but there
//are items still on the list, that means some listeners never
//got to use their commands, meanig they didn't get called for that
//reason/phase they were looking for...
COMMAND* pCommand = pExecutionManager->PopCommand(pThis);
if(pCommand != NULL)
{
//Popoff and execute indented command
QTESTC(pExpectationsManager->PushNestedExpectation(pCommand));
QTESTC(pExecutionManager->ExecuteCommand(pCommand));
QTESTC(pExpectationsManager->PopNestedExpectation(pCommand));
}
else
{
//Display and indicate Commands that never got to be used...
pCommand = pExecutionManager->PopCommand();
pCommand->DisplayCommand();
}
//Cleanup objects
SAFE_DELETE(pCommand);
}
CLEANUP:
THREAD_RETURN;
}
CExecutionManager* CControl::pExecutionManager()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager;
}
CExpectationsManager* CControl::pExpectationsManager()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager->pExpectationsManager();
}
///////////////////////////////////////////////////////////////////////////////
// CExecutionManager
//
///////////////////////////////////////////////////////////////////////////////
CExecutionManager::CExecutionManager(const WCHAR* pwszTestCaseName)
: CTestCases(pwszTestCaseName)
{
HRESULT hr = S_OK;
m_pCRowsetObj = NULL;
m_pExpectationsManager = NULL;
m_pCurrentCommand = NULL;
// This test case was just instantiated, so check the threading model of the creating thread:
// If we are in an STA (single-threaded apartment), then the ThreadID of the calling thread is not
// sufficient to identify the calling control. This is because all notifications are marshalled
// across apartment (thread) boundaries.
m_fFreeThreaded = true;
hr = CoInitializeEx(NULL, 0 /* COINIT_MULTITHREADED */);
if (RPC_E_CHANGED_MODE == hr)
m_fFreeThreaded = false; // We are in an STA
else
CoUninitialize(); // Make sure Init is matched by Uninit
}
CExecutionManager::~CExecutionManager()
{
Terminate();
}
BOOL CExecutionManager::Init()
{
m_pExpectationsManager = new CExpectationsManager(this);
return m_pExpectationsManager != NULL;
}
BOOL CExecutionManager::Terminate()
{
//Need to destory everything here
SAFE_DELETE(m_pCRowsetObj);
SAFE_DELETE(m_pExpectationsManager);
DestroyStacks();
return TRUE;
}
ULONG CExecutionManager::Execute(LPCWSTR wszCommandString, ROWSET_MODE dwRowsetMode)
{
TBEGIN
TESTC(ParseCommandString(wszCommandString));
// If we're running in an STA, listeners cannot receive notifications from multiple controls
if (!m_fFreeThreaded && m_mapControl.GetCount() > 1)
{
TOUTPUT(L"Listeners cannot receive notifications from multiple controls when running in apartment model.");
return TEST_SKIPPED;
}
//Execute
TESTC_PROVIDER(CreateRowset(dwRowsetMode)==S_OK);
TESTC(AdviseListeners());
TESTC(RunControls());
//For some SCENARIOS, it would be useful (ie: save duplicataion of code), if we also
//tested the same senario (same commandstring) with a different rowset type.
//For example: if the request rowset is buffered mode, it might also be useful to
//test the QBU mode code as well. This way the one variation tests both types of rowsets
//for the senario without duplication or maintaince issues...
if(dwRowsetMode & CHANGE_BUFFERRED)
{
//Execute
if(SupportedProperty(KAGPROP_QUERYBASEDUPDATES, DBPROPSET_PROVIDERROWSET))
{
dwRowsetMode |= CHANGE_QBU;
TESTC_(CreateRowset(dwRowsetMode),S_OK);
TESTC(AdviseListeners());
TESTC(RunControls());
}
}
//For example: many SCENARIOS are the "least common demoninator" meaning to get coverage on
//all providers they don't ask for many (or any properties). But as we have seen many properties
//will trigger different code paths and tigger bugs in notifications as well. So if the senario
//requires a bare-bones (default) rowset, then also try and somewhat more functional rowset.
//We obvious can loop through all possible rowset combinations (in a reasonable amount of time)
//but this seems to be the most interesting (default=usally forward only, second=keyset-scrollable).
if(dwRowsetMode & DEFAULT_ROWSET)
{
dwRowsetMode |= (SCROLLBACKWARDS | FETCHBACKWARDS);
if(CreateRowset(dwRowsetMode)==S_OK)
{
TESTC(AdviseListeners());
TESTC(RunControls());
}
}
CLEANUP:
UnadviseListeners();
DestroyStacks();
TRETURN;
}
BOOL CExecutionManager::ParseCommandString(LPCWSTR wszCommandString)
{
yylpwzInput = wszCommandString;
yypExecutionManager = this;
yypCommandListMap = &m_mapCommandList;
yypControlMap = &m_mapControl;
yypListenerMap = &m_mapListener;
yylexInit();
return yyparse() == 0;
}
HRESULT CExecutionManager::CreateRowset(ROWSET_MODE dwRowsetMode)
{
SAFE_DELETE(m_pCRowsetObj);
m_pCRowsetObj = new CRowsetObj();
return m_pCRowsetObj->CreateRowset(dwRowsetMode);
}
BOOL CExecutionManager::DestroyStacks()
{
POSITION pos = 0;
DWORD Key = 0;
//CContol
pos = m_mapControl.GetStartPosition();
while(pos)
{
CControl* pControl = NULL;
m_mapControl.GetNextAssoc(pos, Key, pControl);
SAFE_DELETE(pControl);
}
m_mapControl.RemoveAll();
//CImpIListener
pos = m_mapListener.GetStartPosition();
while(pos)
{
CImpIListener* pListener = NULL;
m_mapListener.GetNextAssoc(pos, Key, pListener);
SAFE_RELEASE(pListener);
}
m_mapListener.RemoveAll();
//CommandList
pos = m_mapCommandList.GetStartPosition();
while(pos)
{
COMMANDLIST* pCommandList = NULL;
m_mapCommandList.GetNextAssoc(pos, Key, pCommandList);
//CCOMAND
POSITION pos2 = pCommandList->GetHeadPosition();
while(pos2)
{
COMMAND* pCommand = NULL;
pCommand = pCommandList->GetNext(pos2);
SAFE_DELETE(pCommand);
}
SAFE_DELETE(pCommandList);
}
m_mapCommandList.RemoveAll();
return TRUE;
}
BOOL CExecutionManager::AdviseListeners(CImpIListener* pListener)
{
//If pListener == NULL, it will Advise all Listeners
//Otherwise just the specified Listener with be Added and Advised
ULONG key = 0;
CImpIListener* pImpIListener = NULL;
IRowset* pIRowset = m_pCRowsetObj ? pCRowsetObj()->pIRowset() : NULL;
//If NULL Advise all Listeners
POSITION pos = m_mapListener.GetStartPosition();
while(pos && pListener==NULL && pIRowset)
{
m_mapListener.GetNextAssoc(pos, key, pImpIListener);
pImpIListener->Advise(pCRowsetObj()->pIRowset());
}
if(pListener && pIRowset)
{
m_mapListener.SetAt(PtrToUlong(pListener), pListener);
pListener->Advise(pCRowsetObj()->pIRowset());
}
return TRUE;
}
BOOL CExecutionManager::UnadviseListeners(CImpIListener* pListener)
{
//If pListener == NULL, it will Unadvise and remove all Listeners
//Otherwise just Unadvise/Remvoe the specified Listener
ULONG key = 0;
CImpIListener* pImpIListener = NULL;
IRowset* pIRowset = m_pCRowsetObj ? pCRowsetObj()->pIRowset() : NULL;
//Remove Listener from list
POSITION pos = m_mapListener.GetStartPosition();
while(pIRowset && pos)
{
m_mapListener.GetNextAssoc(pos, key, pImpIListener);
if(pListener==NULL || pListener==pImpIListener)
{
pImpIListener->Unadvise(pCRowsetObj()->pIRowset());
m_mapListener.RemoveKey(key);
SAFE_RELEASE(pImpIListener);
}
}
return TRUE;
}
BOOL CExecutionManager::RunControls()
{
ULONG_PTR nControlCount = m_mapControl.GetCount();
ULONG key = 0;
CControl* pControl = NULL;
POSITION pos = NULL;
ULONG_PTR i = 0;
//Start all the threads
pos = m_mapControl.GetStartPosition();
for(i = 0; i < nControlCount; i++)
{
m_mapControl.GetNextAssoc(pos, key, pControl);
pControl->Execute();
}
//Wait for all threads to finish
pos = m_mapControl.GetStartPosition();
for(i=0; i<nControlCount; i++)
{
m_mapControl.GetNextAssoc(pos, key, pControl);
pControl->WaitForThread();
}
UnadviseListeners();
DestroyStacks();
return TRUE;
}
POSITION CExecutionManager::GetListenerStartPosition()
{
return m_mapListener.GetStartPosition();
}
CImpIListener* CExecutionManager::NextListener(POSITION& pos)
{
ULONG key = 0;
CImpIListener* pImpIListener = NULL;
m_mapListener.GetNextAssoc(pos, key, pImpIListener);
return pImpIListener;
}
BOOL CExecutionManager::ExecuteCommand(COMMAND* pCOMMAND)
{
ASSERT(pCOMMAND);
//Setup the Thread arguments
THREADARG T1 = { this, pCOMMAND };
BOOL bResult = TRUE;
if(pCOMMAND->m_cThreads)
{
DWORD dwThreadId = 0;
HANDLE hThread = CreateThread(NULL, 1024, CExecutionManager::Thread_ExecuteCommand, &T1, 0, &dwThreadId);
//Wait for it to finish...
WaitForThreads(1, &hThread);
bResult = GetThreadCode(hThread);
}
else
{
//No threads...
bResult = Thread_ExecuteCommand(&T1);
}
return bResult;
}
ULONG CExecutionManager::Thread_ExecuteCommand(void* pv)
{
HRESULT hr = E_FAIL;
BOOL bReturn = FALSE;
CExecutionManager* pThis = (CExecutionManager*)THREAD_FUNC;
COMMAND* pCommand = (COMMAND*)THREAD_ARG1;
//Save the old command
COMMAND* pSavedCommand = pThis->GetCurrentCommand();
pThis->m_pCurrentCommand = pCommand;
//Make our lives easier...
CRowsetObj* pCRowsetObj = pThis->pCRowsetObj();
//Determine the OLEDB Method to call
switch(pCommand->m_eCommandType)
{
case SETDATA:
hr = pCRowsetObj->SetData(pCommand);
break;
case DELETEROWS:
hr = pCRowsetObj->DeleteRows(pCommand);
break;
case INSERTROW:
hr = pCRowsetObj->InsertRow(pCommand);
break;
case GETNEXTROWS:
hr = pCRowsetObj->GetNextRows(pCommand);
break;
case ADDREFROWS:
hr = pCRowsetObj->AddRefRows(pCommand);
break;
case RELEASEROWS:
hr = pCRowsetObj->ReleaseRows(pCommand);
break;
case UPDATE:
hr = pCRowsetObj->Update(pCommand);
break;
case UNDO:
hr = pCRowsetObj->Undo(pCommand);
break;
case RESYNCHROWS:
hr = pCRowsetObj->ResynchRows(pCommand);
break;
case ADDREFROWSET:
pCRowsetObj->AddRefRowset();
hr = S_OK;
break;
case RELEASEROWSET:
if(pCRowsetObj->m_cRowsetRef==0)
{
SAFE_DELETE(pThis->m_pCRowsetObj);
}
else
{
pCRowsetObj->ReleaseRowset();
}
hr = S_OK;
break;
case RESTARTPOSITION:
hr = pCRowsetObj->RestartPosition(pCommand);
break;
case GETROWSAT:
hr = pCRowsetObj->GetRowsAt(pCommand);
break;
case GETROWSATRATIO:
hr = pCRowsetObj->GetRowsAtRatio(pCommand);
break;
case GETROWSBYBOOKMARK:
hr = pCRowsetObj->GetRowsByBookmark(pCommand);
break;
case GETDATA:
hr = pCRowsetObj->GetData(pCommand);
break;
case GETORIGINALDATA:
hr = pCRowsetObj->GetOriginalData(pCommand);
break;
case GETVISIBLEDATA:
hr = pCRowsetObj->GetVisibleData(pCommand);
break;
case ADDCOLUMN:
hr = pCRowsetObj->AddColumn();
if(FAILED(hr))
{
bReturn = FALSE;
goto CLEANUP;
}
break;
case DROPCOLUMN:
hr = pCRowsetObj->DropColumn();
if(FAILED(hr))
{
bReturn = FALSE;
goto CLEANUP;
}
break;
case GETCOLUMNINFO:
hr = pCRowsetObj->GetColumnInfo();
break;
default:
//Unknown Command
TCHECK(hr, S_OK);
}
//Verify HRESULT returned
if(pCommand->m_fCanceled)
{
//if the command was Vetod by a listener then it should be
//one of the "CANCELED" return codes
switch(pCommand->m_eCommandType)
{
case DELETEROWS:
case RESYNCHROWS:
case UPDATE:
if (pCommand->m_cRows == 1)
TESTC_(hr, DB_E_ERRORSOCCURRED)
else
TESTC_(hr, DB_S_ERRORSOCCURRED);
break;
case UNDO:
TESTC_(hr, DB_E_ERRORSOCCURRED);
break;
default:
TESTC_(hr, DB_E_CANCELED);
break;
}
}
else
{
//Otherwise it should be whatever was epected
switch(pCommand->m_hrExpected)
{
case DB_E_NOTREENTRANT:
//According to the spec Providers may or may not support reentrantcy
//And even if they support it, some methods still might not be.
if(pCRowsetObj->GetReentrantEvents()==FALSE)
TESTC_(hr, DB_E_NOTREENTRANT)
else
TEST2C_(hr, S_OK, DB_E_NOTREENTRANT);
pCommand->m_hrExpected = hr;
break;
case DB_E_BADSTARTPOSITION:
//We need to expect DB_E_BADSTARTPOSITION as this indicates to the
//framework that we want to pass a large offset, but the spec
//actually requires DB_S_ENDOFROWSET for 2.x+ providers.
//So we will as well, but still need the 2 states for testing...
TESTC_(hr, DB_S_ENDOFROWSET);
break;
default:
TESTC_(hr, pCommand->m_hrExpected);
break;
}
}
bReturn = TRUE;
CLEANUP:
//Restore the Saved command
pThis->m_pCurrentCommand = pSavedCommand;
return bReturn;
}
CRowsetObj* CExecutionManager::pCRowsetObj()
{
ASSERT(m_pCRowsetObj);
return m_pCRowsetObj;
}
CExpectationsManager* CExecutionManager::pExpectationsManager()
{
ASSERT(m_pExpectationsManager);
return m_pExpectationsManager;
}
COMMAND* CExecutionManager::GetCurrentCommand()
{
return m_pCurrentCommand;
}
COMMANDLIST * CExecutionManager::LookupCommandList()
{
COMMANDLIST * pCommandList = NULL;
// If we're free-threaded, then use the current thread ID to locate the correct command list
if (m_fFreeThreaded)
m_mapCommandList.Lookup(GetCurrentThreadId(), pCommandList);
// Otherwise, there should be only one command list. Get that by iterating.
else
{
POSITION pos = 0;
DWORD dwKey = 0;
ASSERT(1 == m_mapCommandList.GetCount());
pos = m_mapCommandList.GetStartPosition();
m_mapCommandList.GetNextAssoc(pos, dwKey, pCommandList);
}
return pCommandList;
}
BOOL CExecutionManager::IsCommandListEmpty()
{
COMMANDLIST* pCommandList = LookupCommandList();
return pCommandList ? pCommandList->IsEmpty() : TRUE;
}
COMMAND* CExecutionManager::PopCommand(CControl* pControl)
{
//Passing NULL with just pop of the head of the list...
COMMANDLIST* pCommandList = NULL;
POSITION pos = 0;
pCommandList = LookupCommandList();
TESTC(NULL != pCommandList);
pos = pCommandList->GetHeadPosition();
while(pos)
{
POSITION posSave = pos;
COMMAND* pCommand = pCommandList->GetNext(pos);
if(pControl && pCommand->m_pvObjectId != pControl)
continue;
pCommandList->RemoveAt(posSave);
return pCommand;
}
CLEANUP:
return NULL;
}
COMMAND* CExecutionManager::PopCommand
(
CImpIListener* pListener,
DBREASON eReason,
DBEVENTPHASE ePhase
)
{
ASSERT(pListener);
COMMANDLIST* pCommandList = NULL;
POSITION pos = 0;
pCommandList = LookupCommandList();
TESTC(NULL != pCommandList);
pos = pCommandList->GetHeadPosition();
while(pos)
{
POSITION posSave = pos;
COMMAND* pCommand = pCommandList->GetNext(pos);
if(pCommand->m_pvObjectId != pListener)
continue;
if(pCommand->m_ulCommandLevel != GetCurrentCommand()->m_ulCommandLevel)
continue;
if(pCommand->m_eReason != eReason)
continue;
if(pCommand->m_ePhase != ePhase)
continue;
pCommandList->RemoveAt(posSave);
return pCommand;
}
CLEANUP:
return new COMMAND(RETURN_ACCEPT);
}
BOOL CExecutionManager::IsCancelableEvent(DBREASON eReason, DBEVENTPHASE ePhase)
{
return pCRowsetObj()->IsCancelableEvent(eReason, ePhase);
}
/////////////////////////////////////////////////////////////////
// CExpectationsManager
//
/////////////////////////////////////////////////////////////////
CExpectationsManager::CExpectationsManager(CExecutionManager* pExecutionManager)
{
ASSERT(pExecutionManager);
m_pExecutionManager = pExecutionManager;
}
CExpectationsManager::~CExpectationsManager()
{
}
CRowsetObj* CExpectationsManager::pCRowsetObj()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager->pCRowsetObj();
}
CExecutionManager* CExpectationsManager::pExecutionManager()
{
ASSERT(m_pExecutionManager);
return m_pExecutionManager;
}
BOOL CExpectationsManager::PushNextExpectation(EXPECT* pExpect)
{
ASSERT(pExpect);
return pExpect->SetNextPhase();
}
BOOL CExpectationsManager::PushUnwantedReason(CImpIListener* pListener, IRowset* pIRowset, DBREASON eReason)
{
TBEGIN
ASSERT(pListener);
ASSERT(pIRowset);
POSITION pos = 0;
//All Expecations for this reason
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
EXPECT* pExpect = pCommand->m_listExpect.GetNext(pos);
TESTC(pExpect != NULL);
//Should not expect any more notifications
if(pExpect->m_pListener == pListener && pExpect->m_pIRowset == pIRowset && pExpect->m_eReason == eReason)
pExpect->m_bCompleted = TRUE;
}
CLEANUP:
TRETURN;
}
BOOL CExpectationsManager::PushUnwantedPhase(CImpIListener* pListener, IRowset* pIRowset, DBREASON eReason, DBEVENTPHASE ePhase)
{
TBEGIN
ASSERT(pListener);
ASSERT(pIRowset);
POSITION pos = 0;
//All Expecations for this reason/phase should expect the next phase... - not quite correct: see bug 62019
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
EXPECT* pExpect = pCommand->m_listExpect.GetNext(pos);
TESTC(pExpect != NULL);
//Per the spec:DB_S_UNWANTEDPHASE - The provider can optimize by making no further calls with this reason and phase but
//but provider can still call consumer with this reason and phase
if(pExpect->m_pListener == pListener && pExpect->m_pIRowset == pIRowset && pExpect->m_eReason == eReason && pExpect->m_ePhase == ePhase)
pExpect->m_bCompleted = TRUE;
}
CLEANUP:
TRETURN;
}
BOOL CExpectationsManager::PushAdviseExpectation(EXPECT* pExpect)
{
ASSERT(pExpect);
//Advise a new Listener
CImpIListener* pNewListener = new CImpIListener(pExecutionManager());
pExecutionManager()->AdviseListeners(pNewListener);
//Also need to add Expectations for this listener!
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
POSITION pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
EXPECT* pCurExpect = pCommand->m_listExpect.GetNext(pos);
if(pCurExpect->m_pListener == pExpect->m_pListener)
{
//Create a new Expectation for the newly added Listener
//It should be expecting the phases as this listener (Copy constructor)
//This expectation is completly optional, meaning that it is provider
//specific weither the provider notifies Listeners that have advised
//in the middle of a notification. The nice thing about this framework
//is that even if the provider does send notifications we can determine
//we are getting the correct ones and in the correct order...
EXPECT* pNewExpect = new EXPECT(*pCurExpect);
pNewExpect->m_pListener = pNewListener;
pNewExpect->m_fOptional = TRUE;
pNewExpect->m_bCompleted = FALSE;
pNewExpect->m_ulTimesNotified = 0;
//Add this Listener to the List
pCommand->m_listExpect.AddTail(pNewExpect);
}
}
//We have recieved this Notification
PushNextExpectation(pExpect);
return TRUE;
}
BOOL CExpectationsManager::PushUnadviseExpectation(EXPECT* pExpect)
{
TBEGIN
ASSERT(pExpect);
//We need to save a pointer to the Listener
//Since deleting the expectation from the list will remove the same
//Expecation passed in...
CImpIListener* pListener = pExpect->m_pListener;
//Unadvise this Listener
pExecutionManager()->UnadviseListeners(pListener);
//Also need to remove Expectations for this listener!
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
POSITION pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
POSITION posSave = pos;
EXPECT* pCurExpect = pCommand->m_listExpect.GetNext(pos);
if(pCurExpect->m_pListener == pListener)
{
pCommand->m_listExpect.RemoveAt(posSave);
SAFE_DELETE(pCurExpect);
}
}
TRETURN;
}
BOOL CExpectationsManager::PushFalseExpectation(EXPECT* pFalseExpect)
{
//A Listener has Veto'd a change, and we need to figure out whats
//expected for all addtional notifications for FAILEDTODO
TBEGIN
ASSERT(pFalseExpect);
POSITION pos = 0;
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
pCommand->m_fCanceled = (pCommand->m_hrExpected == S_OK);
pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
EXPECT* pExpect = pCommand->m_listExpect.GetNext(pos);
//The Expectations not waiting for this notification
//Should expect FAILEDTODO if they have already started receiving phases
if(pExpect->m_eReason != pFalseExpect->m_eReason)
{
if(!pExpect->IsCompleted())
{
pExpect->m_fCanceled = pCommand->m_fCanceled;
if(pExpect->m_ulTimesNotified)
pExpect->SetPhase(DBEVENTPHASE_FAILEDTODO);
}
}
//Expectations waiting for this notificaiton
//Should expect FAILEDTODO if they have already started receiving phases
if(pExpect->IsEqual(pExpect->m_pListener, pFalseExpect->m_pIRowset, pFalseExpect->m_cRows, pFalseExpect->m_rghRows, pFalseExpect->m_cColumns, pFalseExpect->m_rgColumns, pFalseExpect->m_eReason, pExpect->m_ePhase) ||
(pExpect->m_eReason==DBREASON_ROW_INSERT && pExpect->m_ulTimesNotified==0))
{
if(!pExpect->IsCompleted())
{
pExpect->m_fCanceled = pCommand->m_fCanceled;
if(pExpect->m_ulTimesNotified)
pExpect->SetPhase(DBEVENTPHASE_FAILEDTODO);
}
}
}
TRETURN;
}
BOOL CExpectationsManager::PushNestedExpectation(COMMAND* pCommand)
{
TBEGIN
ASSERT(pCommand);
POSITION pos = 0;
//Setup
DBCOUNTITEM cRows = pCommand->m_cRows;
HROW* rghRows = pCommand->m_rghRows;
IRowset* pIRowset = pCRowsetObj()->pIRowset();
DBCOUNTITEM i;
ROWSTATUS rgRowStatus[MAX_ROW_COUNT];
ULONG rgRefCounts[MAX_ROW_COUNT];
ULONG fFirstChange = FALSE;
//MapRowIds = RowId -> hRow
TESTC(pCRowsetObj()->MapRowIds(pCommand));
//Lookup rowstatus values
for(i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
ROWINFO* pRowInfo = NULL;
rgRowStatus[i] = ROWSTATUS_NOCHANGE;
rgRefCounts[i] = 0;
if(pRowInfo = pCRowsetObj()->GetRowInfo(pCommand->m_rgRowIds[i]))
{
rgRowStatus[i] = pRowInfo->m_eRowStatus;
rgRefCounts[i] = pRowInfo->m_cRefCount;
fFirstChange = pRowInfo->m_fFirstChange;
}
}
pos = pExecutionManager()->GetListenerStartPosition();
while(pos)
{
//Get the next listener
CImpIListener* pListener = pExecutionManager()->NextListener(pos);
TESTC(pListener != NULL);
switch(pCommand->m_eCommandType)
{
case RELEASEROWSET:
//DBREASON_ROWSET_RELEASE
//Release Rowset only gets sent when Reference count goes to 0
if(pCRowsetObj()->m_cRowsetRef==0)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, 0, NULL, 0, NULL, DBREASON_ROWSET_RELEASE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
break;
case GETNEXTROWS:
{
//DBREASON_ROWSET_FETCHPOSITIONCHANGE
if(cRows || pCommand->m_hrExpected==DB_S_ENDOFROWSET)
{
//TODO should only expect FETCHPOSITIONCHANGE if position is going to change!
EXPECT* pExpect = new EXPECT(pListener, pIRowset, 0, NULL, 0, NULL, DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
//DBREASON_ROW_ACTIVATE
//ROW_ACTIVATE is a siglephase event, according to the spec
//the provider makes a single call to OnRowChange for all rows
DBCOUNTITEM cRowsNew = 0;
HROW rghRowsNew[MAX_ROW_COUNT];
memset(rghRowsNew, 0, MAX_ROW_COUNT * sizeof(HROW));
if(cRows && pCommand->m_hrExpected!=DB_S_ENDOFROWSET)
{
//Only expect new rows to be notified
for(DBCOUNTITEM i=0; i<cRows; i++)
if(rghRows[i]==DB_NULL_HROW || rgRefCounts[i]==0)
rghRowsNew[cRowsNew++] = DB_NULL_HROW;
//Some Providers may have a limit to the number of
//rows able to be fetched. DBPROP_MAXOPENROWS
DBCOUNTITEM ulMaxOpenRows = pCRowsetObj()->GetMaxOpenRows();
if(ulMaxOpenRows!=0 && ulMaxOpenRows<cRowsNew)
cRowsNew = ulMaxOpenRows;
}
else if (cRows==0 && pCommand->m_hrExpected==DB_S_ENDOFROWSET)
cRowsNew = MAX_ROW_COUNT;
//If there are any new Rows then expect a notification
if(cRowsNew)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsNew, rghRowsNew, 0, NULL, DBREASON_ROW_ACTIVATE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case RELEASEROWS:
//DBREASON_ROW_RELEASE
{
DBCOUNTITEM cRowsValid = 0;
HROW rghRowsValid[MAX_ROW_COUNT];
//Only expect the valid rows to be notified
//Also only expect rows that have a will have a reference count
//of 0 after ReleaseRows to send notifications
for(DBCOUNTITEM i=0; i<cRows; i++)
if(rghRows[i]!=DB_NULL_HROW && rgRefCounts[i]==1)
rghRowsValid[cRowsValid++] = rghRows[i];
//If there are any Valid Rows then expect a notification
if(cRowsValid)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsValid, rghRowsValid, 0, NULL, DBREASON_ROW_RELEASE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case RESTARTPOSITION:
//DBREASON_ROWSET_FETCHPOSITIONCHANGE
{
//Should only expect FETCHPOSITIONCHANGE if the next fetch position changed
if(pCRowsetObj()->m_ulNextFetchPos != 0)
{
// May require to release rows before RestartPosition if DBPROP_QUICKRESTART = TRUE
//should handle this case
if (!pCRowsetObj()->IsQuickRestart())
{
DBCOUNTITEM cRowsValid = 0;
HROW rghRowsValid[MAX_ROW_COUNT];
pCRowsetObj()->GetRowsToRelease(MAX_ROW_COUNT, cRowsValid, rghRowsValid);
//If there are any Valid Rows then expect a notification
if(cRowsValid)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsValid, rghRowsValid, 0, NULL, DBREASON_ROW_RELEASE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
}
}
EXPECT* pExpect = new EXPECT(pListener, pIRowset, 0, NULL, 0, NULL, DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
//DBREASON_ROWSET_CHANGED
if(pCRowsetObj()->m_fTableAltered)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, 0, NULL, 0, NULL, DBREASON_ROWSET_CHANGED, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case DELETEROWS:
//DBREASON_ROW_DELETE
if(cRows)
{
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRows; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRows[i], 0, NULL, DBREASON_ROW_DELETE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRows, rghRows, 0, NULL, DBREASON_ROW_DELETE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case INSERTROW:
{
//DBREASON_ROW_INSERT
{
pCommand->m_listExpect.AddTail(new EXPECT(pListener, pIRowset, cRows, rghRows, 0, NULL, DBREASON_ROW_INSERT, DBEVENTPHASE_OKTODO));
}
}
break;
case SETDATA:
//DBREASON_ROW_FIRSTCHANGE
//Only is fired in BufferedMode
if(pCRowsetObj()->IsBufferedMode() && fFirstChange)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRows, rghRows, 0, NULL, DBREASON_ROW_FIRSTCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
//DBREASON_COLUMN_SET
{
//We need to setup the expected columns.
pCommand->m_cColumns = pCRowsetObj()->m_cUpBindings;
SAFE_REALLOC(pCommand->m_rgColumns, DBORDINAL, pCommand->m_cColumns);
for(DBORDINAL i=0; i<pCommand->m_cColumns; i++)
pCommand->m_rgColumns[i] = pCRowsetObj()->m_rgUpBindings[i].iOrdinal;
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRows, rghRows, pCommand->m_cColumns, pCommand->m_rgColumns, DBREASON_COLUMN_SET, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
//DBREASON_COLUMN_RECALCULATED
if((pCRowsetObj()->m_dwRowsetMode & COMPUTED_COLUMNS) || (pCRowsetObj()->m_dwRowsetMode & COMPUTED_COLUMNS_INCLUDE))
{
//We need to setup the expected columns.
pCommand->m_cColumns = pCRowsetObj()->m_cUpBindings;
SAFE_REALLOC(pCommand->m_rgColumns, DBORDINAL, pCommand->m_cColumns);
for(DBORDINAL i=0; i<pCommand->m_cColumns; i++)
pCommand->m_rgColumns[i] = pCRowsetObj()->m_rgUpBindings[i].iOrdinal;
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRows, rghRows, pCommand->m_cColumns, pCommand->m_rgColumns, DBREASON_COLUMN_RECALCULATED, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
break;
case SEEK:
//DBREASON_ROWSET_FETCHPOSITIONCHANGE
{
//TODO should only expect FETCHPOSITIONCHANGE if position is going to change!
EXPECT* pExpect = new EXPECT(pListener, pIRowset, 0, NULL, 0, NULL, DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
break;
case GETROWSAT:
case GETROWSBYBOOKMARK:
case GETROWSATRATIO:
//DBREASON_ROW_ACTIVATE
if(cRows)
{
//ROW_ACTIVATE is a siglephase event, according to the spec
//the provider makes a single call to OnRowChange for all rows
/*
DBCOUNTITEM cRowsExpected = cRows;
if(pCommand->m_dwOption == DBBMK_LAST && pCommand->m_eCommandType == GETROWSAT)
cRowsExpected = 1;
DBCOUNTITEM cRowsNew = 0;
HROW rghRowsNew[MAX_ROW_COUNT];
//Only expect new rows to be notified
for(DBCOUNTITEM i=0; i<cRowsExpected; i++)
if(rghRows[i]==DB_NULL_HROW || rgRefCounts[i]==0)
rghRowsNew[cRowsNew++] = DB_NULL_HROW;
//Some Providers may have a limit to the number of
//rows able to be fetched. DBPROP_MAXOPENROWS
DBCOUNTITEM ulMaxOpenRows = pCRowsetObj()->GetMaxOpenRows();
if(ulMaxOpenRows!=0 && ulMaxOpenRows<cRowsNew)
cRowsNew = ulMaxOpenRows;
//If there are any new Rows then expect a notification
if(cRowsNew)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsNew, rghRowsNew, 0, NULL, DBREASON_ROW_ACTIVATE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
*/
//The provider should send this reason for newly fetched rows only,
//but it might be expensive for providers to determine whether or not a row is newly fetched
// so will expect DBREASON_ROW_ACTIVATE for all rows
DBCOUNTITEM cRowsExpected = cRows;
if(pCommand->m_dwOption == DBBMK_LAST && pCommand->m_eCommandType == GETROWSAT)
cRowsExpected = 1;
HROW rghRowsExpect[MAX_ROW_COUNT];
//All rows might be notified
for(DBCOUNTITEM i=0; i<cRowsExpected; i++)
if(rghRows[i]==DB_NULL_HROW || rgRefCounts[i]==0)
rghRowsExpect[i] = DB_NULL_HROW;
else
rghRowsExpect[i] = rghRows[i];
//Some Providers may have a limit to the number of
//rows able to be fetched. DBPROP_MAXOPENROWS
DBCOUNTITEM ulMaxOpenRows = pCRowsetObj()->GetMaxOpenRows();
if(ulMaxOpenRows!=0 && ulMaxOpenRows<cRowsExpected)
cRowsExpected = ulMaxOpenRows;
if(cRowsExpected)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsExpected, rghRowsExpect, 0, NULL, DBREASON_ROW_ACTIVATE, DBEVENTPHASE_DIDEVENT);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case RESYNCHROWS:
//DBREASON_ROW_RESYNCH
{
DBCOUNTITEM cRowsResynched = 0;
HROW rghRowsResynched[MAX_ROW_COUNT];
//Find all "Pending" rows
for(DBCOUNTITEM i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
//According to the spec resynch row notifications
//are always, regardless if the row needed resynching
//or not. So for all rows passed to IRowsetResynch
//all should be notified.
if(rghRows[i] != DB_NULL_HROW)
rghRowsResynched[cRowsResynched++] = rghRows[i];
}
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRowsResynched; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRowsResynched[i], 0, NULL, DBREASON_ROW_RESYNCH, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsResynched, rghRowsResynched, 0, NULL, DBREASON_ROW_RESYNCH, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case UNDO:
//DBREASON_ROW_UNDOCHANGE
{
DBCOUNTITEM cRowsChanged = 0;
HROW rghRowsChanged[MAX_ROW_COUNT];
//Find all "Changed" rows
for(DBCOUNTITEM i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
//UndoChange is only sent for rows that have changed
//and are undone, other "no-op" rows do not have notifications
if(rghRows[i] && rgRowStatus[i] == ROWSTATUS_CHANGED)
rghRowsChanged[cRowsChanged++] = rghRows[i];
}
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRowsChanged; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRowsChanged[i], 0, NULL, DBREASON_ROW_UNDOCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsChanged, rghRowsChanged, 0, NULL, DBREASON_ROW_UNDOCHANGE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
//DBREASON_ROW_UNDOINSERT
{
DBCOUNTITEM cRowsInserted = 0;
HROW rghRowsInserted[MAX_ROW_COUNT];
//Find all "Inserted" rows
for(DBCOUNTITEM i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
//UndoInsert is only sent for rows that have changed
//and are undone, other "no-op" rows do not have notifications
if(rghRows[i] && rgRowStatus[i] == ROWSTATUS_INSERTED)
rghRowsInserted[cRowsInserted++] = rghRows[i];
}
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRowsInserted; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRowsInserted[i], 0, NULL, DBREASON_ROW_UNDOINSERT, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsInserted, rghRowsInserted, 0, NULL, DBREASON_ROW_UNDOINSERT, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
//DBREASON_ROW_UNDODELETE
{
DBCOUNTITEM cRowsDeleted = 0;
HROW rghRowsDeleted[MAX_ROW_COUNT];
//Find all "Deleted" rows
for(DBCOUNTITEM i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
//UndoDelete is only sent for rows that have changed
//and are undone, other "no-op" rows do not have notifications
if(rghRows[i] && rgRowStatus[i] == ROWSTATUS_DELETED)
rghRowsDeleted[cRowsDeleted++] = rghRows[i];
}
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRowsDeleted; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRowsDeleted[i], 0, NULL, DBREASON_ROW_UNDODELETE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsDeleted, rghRowsDeleted, 0, NULL, DBREASON_ROW_UNDODELETE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
case UPDATE:
//DBREASON_ROW_UPDATE
{
DBCOUNTITEM cRowsPending = 0;
HROW rghRowsPending[MAX_ROW_COUNT];
//Find all "Pending" rows
for(DBCOUNTITEM i=0; i<cRows || i<pCommand->m_dwOption; i++)
{
//Update is only sent for rows that have changed
//and are undone, other "no-op" rows do not have notifications
if(rghRows[i] && rgRowStatus[i] != ROWSTATUS_NOCHANGE)
rghRowsPending[cRowsPending++] = rghRows[i];
}
if(pCRowsetObj()->GetGranularity() == DBPROPVAL_NT_SINGLEROW)
{
for(DBCOUNTITEM i=0; i<cRowsPending; i++)
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, ONE_ROW, &rghRowsPending[i], 0, NULL, DBREASON_ROW_UPDATE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
else
{
EXPECT* pExpect = new EXPECT(pListener, pIRowset, cRowsPending, rghRowsPending, 0, NULL, DBREASON_ROW_UPDATE, DBEVENTPHASE_OKTODO);
pCommand->m_listExpect.AddTail(pExpect);
}
}
break;
default:
//No expected notifications
break;
}
}
CLEANUP:
TRETURN
}
BOOL CExpectationsManager::PopNestedExpectation(COMMAND* pCommand)
{
TBEGIN
while(!pCommand->m_listExpect.IsEmpty())
{
EXPECT* pExpect = pCommand->m_listExpect.RemoveHead();
TCHECK(pExpect != NULL, TRUE);
//This maybe a optional notification
//Optional notifications are for Listeners that have been advised in the
//middle, it is provider specific weither or not the provider sends
//any notifications to this listener until the next notification
if(pExpect->m_fOptional)
{
if(pExpect->m_bCompleted)
TCHECK(pExpect->VerifyComplete(), TRUE);
}
//If the Notification was veto'd by a listener
else if(pCommand->m_fCanceled)
{
//If it started to receive Notifications, then it should have an
//Incomplete sequence, otherwise no phases should have been fired
if(pExpect->m_fCanceled)
{
TCHECK(pExpect->VerifyInComplete(),TRUE);
}
else
{
TCHECK(pExpect->VerifyComplete(),TRUE);
}
}
else
{
//If it wasn't vetod by a listener then the phases should be
//COMPLETE if the expected HRESULT was S_OK (default), or if we were
//purposly inposing an error, it should be what we expect...
switch(pCommand->m_hrExpected)
{
case E_INVALIDARG:
case DB_E_NOTREENTRANT:
case DB_E_ERRORSOCCURRED:
case DB_E_BADROWHANDLE:
case DB_E_BADACCESSORHANDLE:
//Failures that should have never been notified
TCHECK(pExpect->VerifyInComplete(),TRUE);
break;
case DB_S_ENDOFROWSET:
//Should only get INCOMPLETE if asked for no rows
//otherwsie should have changed the position
//TODO really should be a more robust way of knowing wither the fetchposition is going to change
if(pCommand->m_cRows==0)
{
TCHECK(pExpect->VerifyInComplete(),TRUE);
}
else
{
TCHECK(pExpect->VerifyComplete(),TRUE);
}
break;
case DB_E_BADSTARTPOSITION:
//Canceled, should have been an incomplete sequence
TCHECK(pExpect->VerifyInComplete(),TRUE);
break;
case S_OK:
case DB_S_ERRORSOCCURRED:
case DB_S_COMMANDREEXECUTED:
//Success, should have been notified for all phases
TCHECK(pExpect->VerifyComplete(),TRUE);
break;
default:
//Unhandled HRESULT
TCHECK(TRUE,FALSE);
}
}
SAFE_DELETE(pExpect);
}
TRETURN;
}
EXPECT* CExpectationsManager::FindExpectation
(
CImpIListener* pListener,
IRowset* pIRowset,
DBCOUNTITEM cRows,
HROW* rghRows,
DBORDINAL cColumns,
DBORDINAL rgColumns[],
DBREASON eReason,
DBEVENTPHASE ePhase,
BOOL fCantDeny
)
{
ASSERT(pListener);
ASSERT(pIRowset);
//PopExpectation
EXPECT* pExpect = PopExpectation(pListener, pIRowset, cRows, rghRows, cColumns, rgColumns, eReason, ePhase);
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
//Received a Notification it was not expecting, Output debug info
if(pExpect == NULL)
{
DisplayNotification(L"Unexpected: ", cRows, rghRows, cColumns, rgColumns, eReason, ePhase);
goto CLEANUP;
}
//Record this notification
pExpect->m_ulTimesNotified++;
//If we purposely are expecting an error (called OLEDB method with invalid results)
//Then we will allow DBEVENTPHASE_FAILEDTODO at anytime
if(ePhase==DBEVENTPHASE_FAILEDTODO && pCommand->m_hrExpected!=S_OK)
TESTC(PushFalseExpectation(pExpect));
//DBREASON_ROW_ACTIVATE
//DBREASON_ROW_INSERT
if(eReason == DBREASON_ROW_ACTIVATE || eReason == DBREASON_ROW_INSERT)
{
//With these reason you have no way of knowing ahead of time the
//row handle values, just set when notified and then remember them...
for(DBCOUNTITEM i=0; i<cRows; i++)
{
if(pExpect->m_rghRows[i] == DB_NULL_HROW)
{
//Update the expectation
pExpect->m_rghRows[i] = rghRows[i];
//Update the RowInfo as well...
//TODO: The expectation should also have RowIDs to match this up with...
ROWINFO* pRowInfo = pCRowsetObj()->GetRowInfo(pCommand->m_rgRowIds[i]);
if(pRowInfo)
{
if(pRowInfo->m_hRow == DB_NULL_HROW || pRowInfo->m_cRefCount==0)
pRowInfo->m_hRow = rghRows[i];
}
}
}
}
//We need to handle UnWanted Phases.
//Since this is an optimization, its upto the provider wiether or not they send
//unwanted phases. We need to be prepared and handle both cases...
//Note that we never go to an endless loop because ePhase is a valid phase for eReason and we expect all phases for the reason
while(pExpect->m_ePhase != ePhase && !pExpect->m_pListener->IsWantedPhase(eReason, pExpect->m_ePhase))
{
//Get the next phase in sequence
pExpect->SetNextPhase();
}
//We need to handle Optional Phases.
//Since it is provider specific wither newly advised listeners reveice some
//or all the phases of the current notification, we need to allow the case
//where its the first time and the starting phases is "later" than whats expected...
if(pExpect->m_ePhase != ePhase && pExpect->m_fOptional)
{
//Get the next phase in sequence
if(pExpect->m_ulTimesNotified == 1)
pExpect->SetNextPhase();
}
//Verify the Notifcation
QTESTC(pExpect->VerifyEqual(pListener, pIRowset, cRows, rghRows, cColumns, rgColumns, eReason, ePhase));
CLEANUP:
return pExpect;
}
EXPECT* CExpectationsManager::PopExpectation
(
CImpIListener* pListener,
IRowset* pIRowset,
DBCOUNTITEM cRows,
HROW* rghRows,
DBORDINAL cColumns,
DBORDINAL rgColumns[],
DBREASON eReason,
DBEVENTPHASE ePhase
)
{
ASSERT(pListener);
ASSERT(pIRowset);
DBCOUNTITEM i = 0;
COMMAND* pCommand = pExecutionManager()->GetCurrentCommand();
POSITION pos = pCommand->m_listExpect.GetHeadPosition();
while(pos)
{
EXPECT* pExpect = pCommand->m_listExpect.GetNext(pos);
if(pExpect->m_pListener != pListener)
continue;
if(pExpect->m_pIRowset != pIRowset)
continue;
if(pExpect->m_eReason != eReason)
continue;
//This is a hack for DB_S_ENDOFROWSET, since we don't neccessaryly
//know ahead of time the number of rows in the rowset without traversing
//the rowset, and traversing the rowset would fire ROW_ACTIVATE and the
//next call to GetNextRows would now not fire ROW_ACTIVE...
if(pCommand->m_hrExpected == DB_S_ENDOFROWSET)
pExpect->m_cRows = cRows;
//Provider should send DBREASON_ROW_ACTIVATE for newly fetched rows only, but may send far all rows
if (eReason == DBREASON_ROW_ACTIVATE && pExpect->m_cRows > cRows)
{
//get only newly fetched rows
DBCOUNTITEM cRowsExpect=0;
for(i=0; i<pExpect->m_cRows; i++)
if (pExpect->m_rghRows[i] == DB_NULL_HROW)
cRowsExpect++;
for(i=0; i<cRowsExpect; i++)
pExpect->m_rghRows[i] = DB_NULL_HROW;
pExpect->m_cRows = cRowsExpect;
}
if(pExpect->m_cRows != cRows)
continue;
BOOL bEqual = TRUE;
for(i=0; i<cRows; i++)
if(pExpect->m_rghRows[i] != DB_NULL_HROW)
if(!IsSameRow(pIRowset, pExpect->m_rghRows[i], rghRows[i]))
bEqual = FALSE;
if(!bEqual)
continue;
if(pExpect->m_cColumns != cColumns)
continue;
bEqual = TRUE;
for(i=0; i<cColumns; i++)
if(pExpect->m_rgColumns[i] != rgColumns[i])
bEqual = FALSE;
if(!bEqual)
continue;
//Finally found the right expectation!
return pExpect;
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
// IRNOTIFY.Y
//
///////////////////////////////////////////////////////////////////////////////
/*
%{
#include "MODStandard.hpp" //ModuleCore headers
#include "IRNotify.h" //IRowsetNotify header
#define lint //Removes warnings for unused labels
// Input string to parse
LPCWSTR yylpwzInput;
CExecutionManager *yypExecutionManager;
COMMANDLIST *yypCommandList;
COMMANDLISTMAP *yypCommandListMap;
CONTROLMAP *yypControlMap;
LISTENERMAP *yypListenerMap;
static LPVOID pvObjectId = NULL;
static CControl* pControl = NULL;
static DBREASON eReason = 0;
static DBEVENTPHASE ePhase = 0;
static ULONG ulCommandLevel = 1;
static ULONG cRows = 0;
static ULONG rgRowIds[MAX_ROW_COUNT];
static ULONG cColumns = 0;
static ULONG rgColumns[MAX_ROW_COUNT];
static HRESULT hrExpected = S_OK;
static ULONG cThreads = 0;
%}
%union {
ULONG Number;
ULONG IdentifierId;
}
%token <Number> yyNUMBER
%token <IdentifierId> yyIDENTIFIERID
//Notification REASONS
%token yyROWSET_FETCHPOSITIONCHANGE
%token yyROWSET_RELEASE
%token yyROWSET_CHANGED
%token yyCOLUMN_SET
%token yyCOLUMN_RECALCULATED
%token yyROW_ACTIVATE
%token yyROW_RELEASE
%token yyROW_DELETE
%token yyROW_FIRSTCHANGE
%token yyROW_INSERT
%token yyROW_RESYNCH
%token yyROW_UNDOCHANGE
%token yyROW_UNDOINSERT
%token yyROW_UNDODELETE
%token yyROW_UPDATE
//Notification PHASES
%token yyOKTODO
%token yyABOUTTODO
%token yySYNCHAFTER
%token yyDIDEVENT
%token yyFAILEDTODO
//OLEDB Methods (which generate Notifications)
%token yyGETDATA
%token yyGETORIGINALDATA
%token yyGETVISIBLEDATA
%token yyRELEASEROWSET
%token yyADDREFROWSET
%token yyGETNEXTROWS
%token yyRELEASEROWS
%token yyADDREFROWS
%token yyRESTARTPOSITION
%token yyDELETEROWS
%token yyINSERTROW
%token yySETDATA
%token yySEEK
%token yyGETROWSAT
%token yyGETROWSBYBOOKMARK
%token yyRESYNCHROWS
%token yyGETROWSATRATIO
%token yyUNDO
%token yyUPDATE
%token yyABORT
%token yyCOMMIT
%token yyADDCOLUMN
%token yyDROPCOLUMN
%token yyGETCOLUMNINFO
//Identifiers
%token yyCONTROL
%token yyLISTENER
%token yyTHREAD
%token yyDBBMK_FIRST
%token yyDBBMK_LAST
%token yyRETURN_ACCEPT
%token yyRETURN_VETO
%token yyRETURN_EFAIL
%token yyRETURN_EOUTOFMEMORY
%token yyRETURN_EINVALIDARG
%token yyRETURN_UNWANTEDREASON
%token yyRETURN_UNWANTEDPHASE
%token yyRETURN_ADVISE
%token yyRETURN_UNADVISE
//hrExpected
%token yyDB_S_ENDOFROWSET
%token yyDB_E_BADSTARTPOSITION
%token yyDB_E_NOTREENTRANT
%token yyDB_S_ERRORSOCCURRED
%token yyDB_E_ERRORSOCCURRED
%token yyE_INVALIDARG
%token yyDB_E_ROWSNOTRELEASED
%token yyDB_E_BADACCESSORHANDLE
%token yyDB_E_BADROWHANDLE
%%
Notification_Test : {ulCommandLevel = 1; }
'{' ListenerList ControlList '}'
ListenerList : Listener | ListenerList Listener
//Listener Syntax
Listener : yyLISTENER yyIDENTIFIERID ';'
{yypListenerMap->SetAt($2,new CImpIListener(yypExecutionManager));}
ControlList : Control | ControlList Control
Control : '{' yyCONTROL yyIDENTIFIERID ';'
{
pControl = new CControl(yypExecutionManager);
pvObjectId = pControl;
ulCommandLevel = 1;
yypControlMap->SetAt($3,pControl);
yypCommandList = new COMMANDLIST;
yypCommandListMap->SetAt(pControl->GetThreadId(), yypCommandList);
}
'{' ControlStmtList '}'
'}'
ControlStmtList : ControlStmt | ControlStmtList ControlStmt
ControlStmt : OLEDBMethod '{' ListenerStmtList '}'
{
ulCommandLevel++;
pvObjectId = pControl;
}
| OLEDBMethod '{' '}'
{
ulCommandLevel++;
pvObjectId = pControl;
}
ListenerStmtList : ListenerStmt | ListenerStmtList ListenerStmt
ListenerStmt : ListenerIdentifier '.' Reason '.' Phase '.' ListenerMethod
ListenerIdentifier : yyIDENTIFIERID
{CImpIListener *pImpIListener;
BOOL Ok = yypListenerMap->Lookup($1,pImpIListener);
if (!Ok) yyerror("Invalid Listener");
pvObjectId = pImpIListener;}
ListenerMethod : ListenerReturn
{
}
| OLEDBMethod '{' ListenerStmtList '}'
{
}
| OLEDBMethod '{' '}'
{
}
| yyTHREAD { cThreads = 1; } '{' ListenerMethod '}'
{
cThreads = 0;
}
ListenerReturn : yyRETURN_ACCEPT
{yypCommandList->AddTail(
new COMMAND(RETURN_ACCEPT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
| yyRETURN_VETO
{yypCommandList->AddTail(
new COMMAND(RETURN_VETO, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
| yyRETURN_EFAIL
{yypCommandList->AddTail(
new COMMAND(RETURN_EFAIL, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
| yyRETURN_EOUTOFMEMORY
{yypCommandList->AddTail(
new COMMAND(RETURN_EOUTOFMEMORY, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
| yyRETURN_EINVALIDARG
{yypCommandList->AddTail(
new COMMAND(RETURN_EINVALIDARG, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
| yyRETURN_UNWANTEDREASON
{yypCommandList->AddTail(
new COMMAND(RETURN_UNWANTEDREASON, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
|yyRETURN_UNWANTEDPHASE
{yypCommandList->AddTail(
new COMMAND(RETURN_UNWANTEDPHASE, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
|yyRETURN_ADVISE
{yypCommandList->AddTail(
new COMMAND(RETURN_ADVISE, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
|yyRETURN_UNADVISE
{yypCommandList->AddTail(
new COMMAND(RETURN_UNADVISE, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase));} //ePhase
OLEDBMethod : ReleaseRowsetMethod
| GetNextRows
| ReleaseRowsMethod
| RestartPositionMethod
| DeleteRowsMethod
| InsertRowMethod
| SetDataMethod
| SeekMethod
| GetRowsAtMethod
| GetRowsByBookmarkMethod
| ResynchRowsMethod
| GetRowsAtRatioMethod
| UndoMethod
| UpdateMethod
| AddRefRowsetMethod
| AddRefRowsMethod
| GetDataMethod
| GetOriginalDataMethod
| GetVisibleDataMethod
| AbortMethod
| CommitMethod
| AddColumnMethod
| DropColumnMethod
| GetColumnInfoMethod
ReleaseRowsMethod : yyRELEASEROWS '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(RELEASEROWS, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
GetNextRows : yyGETNEXTROWS '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(GETNEXTROWS, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
ReleaseRowsetMethod : yyRELEASEROWSET '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(RELEASEROWSET, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
RestartPositionMethod : yyRESTARTPOSITION '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(RESTARTPOSITION, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
DeleteRowsMethod : yyDELETEROWS '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(DELETEROWS, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
InsertRowMethod : yyINSERTROW '(' yyIDENTIFIERID ')'
{yypCommandList->AddTail(
new COMMAND(INSERTROW, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
1, //cRows
&($3)));} //rgRowIds
| yyINSERTROW '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'
{yypCommandList->AddTail(
new COMMAND(INSERTROW, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
1, //cRows
&($3)));} //rgRowIds
SetDataMethod : yySETDATA '(' yyIDENTIFIERID ',' OrdinalList ')'
{yypCommandList->AddTail(
new COMMAND(SETDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
1, //cRows
&($3), //rgRowIds
cColumns, //cColumns
rgColumns));} //rgColumns
| yySETDATA '(' yyIDENTIFIERID ',' OrdinalList ',' ExpectedHRESULT ')'
{yypCommandList->AddTail(
new COMMAND(SETDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
1, //cRows
&($3), //rgRowIds
cColumns, //cColumns
rgColumns));} //rgColumns
SeekMethod : yySEEK '(' yyNUMBER ')'
{yypCommandList->AddTail(
new COMMAND(SEEK, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
$3, //cRows
rgRowIds));} //rgRowIds
| yySEEK '(' yyNUMBER ',' ExpectedHRESULT ')'
{yypCommandList->AddTail(
new COMMAND(SEEK, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
$3, //cRows
rgRowIds));} //rgRowIds
GetRowsAtMethod : yyGETROWSAT '(' yyDBBMK_FIRST ',' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds, //rgRowIds
0, //cColumns
NULL, //rgColumns
DBBMK_FIRST));} //dwOption
| yyGETROWSAT '(' yyDBBMK_FIRST ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
0, //cRows
NULL, //rgRowIds
0, //cColumns
NULL, //rgColumns
DBBMK_FIRST));} //dwOption
| yyGETROWSAT '(' yyDBBMK_LAST ',' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds, //rgRowIds
0, //cColumns
NULL, //rgColumns
DBBMK_LAST));} //dwOption
| yyGETROWSAT '(' yyDBBMK_LAST ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
0, //cRows
NULL, //rgRowIds
0, //cColumns
NULL, //rgColumns
DBBMK_LAST));} //dwOption
GetRowsByBookmarkMethod : yyGETROWSBYBOOKMARK '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSBYBOOKMARK, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
ResynchRowsMethod : yyRESYNCHROWS '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(RESYNCHROWS, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
GetRowsAtRatioMethod : yyGETROWSATRATIO '(' yyNUMBER ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSATRATIO, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
0, //cRows
NULL, //rgRowIds
0, //cColumns
NULL, //rgColumns
$3));} //dwOption
| yyGETROWSATRATIO '(' yyNUMBER ',' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(GETROWSATRATIO, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds, //rgRowIds
0, //cColumns
NULL, //rgColumns
$3));} //dwOption
UndoMethod : yyUNDO '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(UNDO, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
UpdateMethod : yyUPDATE '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(UPDATE, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
AddRefRowsMethod : yyADDREFROWS '(' IdentifierList ')'
{yypCommandList->AddTail(
new COMMAND(ADDREFROWS, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
cRows, //cRows
rgRowIds));} //rgRowIds
AddRefRowsetMethod : yyADDREFROWSET '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(ADDREFROWSET, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
GetDataMethod : yyGETDATA '(' yyIDENTIFIERID ')'
{yypCommandList->AddTail(
new COMMAND(GETDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
1, //cRows
&($3) ));} //rgRowIds
GetOriginalDataMethod : yyGETORIGINALDATA '(' yyIDENTIFIERID ')'
{yypCommandList->AddTail(
new COMMAND(GETORIGINALDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
1, //cRows
&($3) ));} //rgRowIds
| yyGETORIGINALDATA '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'
{yypCommandList->AddTail(
new COMMAND(GETORIGINALDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
1, //cRows
&($3)));} //rgRowIds
GetVisibleDataMethod : yyGETVISIBLEDATA '(' yyIDENTIFIERID ')'
{yypCommandList->AddTail(
new COMMAND(GETVISIBLEDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
S_OK, //hrExpected
1, //cRows
&($3) ));} //rgRowIds
| yyGETVISIBLEDATA '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'
{yypCommandList->AddTail(
new COMMAND(GETVISIBLEDATA, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected, //hrExpected
1, //cRows
&($3)));} //rgRowIds
AbortMethod : yyABORT '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(ABORT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
CommitMethod : yyCOMMIT '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(COMMIT, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
AddColumnMethod : yyADDCOLUMN '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(ADDCOLUMN, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
DropColumnMethod : yyDROPCOLUMN '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(DROPCOLUMN, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
GetColumnInfoMethod : yyGETCOLUMNINFO '(' EmptyList ')'
{yypCommandList->AddTail(
new COMMAND(GETCOLUMNINFO, //eCOMMANDTYPE
pvObjectId, //pvObjectId
ulCommandLevel, //ulCommandLevel
cThreads, //cThreads
eReason, //eReason
ePhase, //ePhase
hrExpected));} //hrExpected
OrdinalList : yyNUMBER
{cColumns = 0; rgColumns[cColumns++] = $1;}
| OrdinalList ',' yyNUMBER
{rgColumns[cColumns++] = $3;}
IdentifierList :
yyIDENTIFIERID
{
cRows = 0;
rgRowIds[cRows++] = $1;
hrExpected = S_OK;
}
| EmptyList
{
}
| IdentifierList ',' yyIDENTIFIERID
{
rgRowIds[cRows++] = $3;
}
| IdentifierList ',' ExpectedHRESULT
{
}
EmptyList : ExpectedHRESULT
{
cRows = 0;
cColumns = 0;
}
| // Empty
{
cRows = 0;
cColumns = 0;
hrExpected = S_OK;
}
ExpectedHRESULT :
yyDB_S_ENDOFROWSET
{
cRows = SIZEOF_TABLE;
hrExpected = DB_S_ENDOFROWSET;
}
| yyDB_E_BADSTARTPOSITION
{
hrExpected = DB_E_BADSTARTPOSITION;
}
| yyDB_E_NOTREENTRANT
{
hrExpected = DB_E_NOTREENTRANT;
}
| yyDB_S_ERRORSOCCURRED
{
hrExpected = DB_S_ERRORSOCCURRED;
}
| yyDB_E_ERRORSOCCURRED
{
hrExpected = DB_E_ERRORSOCCURRED;
}
| yyE_INVALIDARG
{
hrExpected = E_INVALIDARG;
}
| yyDB_E_ROWSNOTRELEASED
{
hrExpected = DB_E_ROWSNOTRELEASED;
}
| yyDB_E_BADACCESSORHANDLE
{
hrExpected = DB_E_BADACCESSORHANDLE;
}
| yyDB_E_BADROWHANDLE
{
hrExpected = DB_E_BADROWHANDLE;
}
Reason :
yyROWSET_FETCHPOSITIONCHANGE
{eReason = DBREASON_ROWSET_FETCHPOSITIONCHANGE;}
| yyROWSET_RELEASE
{eReason = DBREASON_ROWSET_RELEASE;}
| yyROWSET_CHANGED
{eReason = DBREASON_ROWSET_CHANGED;}
| yyCOLUMN_SET
{eReason = DBREASON_COLUMN_SET;}
| yyCOLUMN_RECALCULATED
{eReason = DBREASON_COLUMN_RECALCULATED;}
| yyROW_ACTIVATE
{eReason = DBREASON_ROW_ACTIVATE;}
| yyROW_RELEASE
{eReason = DBREASON_ROW_RELEASE;}
| yyROW_DELETE
{eReason = DBREASON_ROW_DELETE;}
| yyROW_FIRSTCHANGE
{eReason = DBREASON_ROW_FIRSTCHANGE;}
| yyROW_INSERT
{eReason = DBREASON_ROW_INSERT;}
| yyROW_RESYNCH
{eReason = DBREASON_ROW_RESYNCH;}
| yyROW_UNDOCHANGE
{eReason = DBREASON_ROW_UNDOCHANGE;}
| yyROW_UNDOINSERT
{eReason = DBREASON_ROW_UNDOINSERT;}
| yyROW_UNDODELETE
{eReason = DBREASON_ROW_UNDODELETE;}
| yyROW_UPDATE
{eReason = DBREASON_ROW_UPDATE;}
Phase : yyOKTODO
{ePhase = DBEVENTPHASE_OKTODO;}
| yyABOUTTODO
{ePhase = DBEVENTPHASE_ABOUTTODO;}
| yySYNCHAFTER
{ePhase = DBEVENTPHASE_SYNCHAFTER;}
| yyDIDEVENT
{ePhase = DBEVENTPHASE_DIDEVENT;}
| yyFAILEDTODO
{ePhase = DBEVENTPHASE_FAILEDTODO;}
%%
int yyerror(char*s)
{
return 0;
}
// Keyword Table for Parser
typedef CMap <CString, LPCTSTR, ULONG, ULONG> TABLE;
class KEYWORDTABLE : public TABLE
{
public:
KEYWORDTABLE();
~KEYWORDTABLE();
};
KEYWORDTABLE::KEYWORDTABLE()
{
SetAt(_T("IRowset::GetData"),yyGETDATA);
SetAt(_T("IRowsetUpdate::GetOriginalData"),yyGETORIGINALDATA);
SetAt(_T("IRowsetResynch::GetVisibleData"),yyGETVISIBLEDATA);
SetAt(_T("IRowsetChange::SetData"),yySETDATA);
SetAt(_T("IRowsetIndex::Seek"),yySEEK);
SetAt(_T("IRowsetChange::DeleteRows"),yyDELETEROWS);
SetAt(_T("IRowsetChange::InsertRow"),yyINSERTROW);
SetAt(_T("IRowsetUpdate::Update"),yyUPDATE);
SetAt(_T("IRowsetUpdate::Undo"),yyUNDO);
SetAt(_T("IRowset::GetNextRows"),yyGETNEXTROWS);
SetAt(_T("IRowset::ReleaseRows"),yyRELEASEROWS);
SetAt(_T("IRowset::AddRefRows"),yyADDREFROWS);
SetAt(_T("IRowset::AddRef"),yyADDREFROWSET);
SetAt(_T("IRowset::Release"),yyRELEASEROWSET);
SetAt(_T("IRowsetResynch::ResynchRows"),yyRESYNCHROWS);
SetAt(_T("IRowsetLocate::GetRowsAt"),yyGETROWSAT);
SetAt(_T("IRowsetScroll::GetRowsAtRatio"),yyGETROWSATRATIO);
SetAt(_T("IRowset::RestartPosition"),yyRESTARTPOSITION);
SetAt(_T("IRowsetLocate::GetRowsByBookmark"),yyGETROWSBYBOOKMARK);
SetAt(_T("ITransaction::Abort"), yyABORT);
SetAt(_T("ITransaction::Commit"), yyCOMMIT);
SetAt(_T("ITableDefinition::AddColumn"), yyADDCOLUMN);
SetAt(_T("ITableDefinition::DropColumn"), yyDROPCOLUMN);
SetAt(_T("IColumnsInfo::GetColumnInfo"), yyGETCOLUMNINFO);
//Listener Return values
SetAt(_T("RETURN_ACCEPT"),yyRETURN_ACCEPT);
SetAt(_T("RETURN_VETO"),yyRETURN_VETO);
SetAt(_T("RETURN_EFAIL"),yyRETURN_EFAIL);
SetAt(_T("RETURN_EOUTOFMEMORY"),yyRETURN_EOUTOFMEMORY);
SetAt(_T("RETURN_EINVALIDARG"),yyRETURN_EINVALIDARG);
SetAt(_T("RETURN_UNWANTEDREASON"),yyRETURN_UNWANTEDREASON);
SetAt(_T("RETURN_UNWANTEDPHASE"),yyRETURN_UNWANTEDPHASE);
SetAt(_T("RETURN_ADVISE"),yyRETURN_ADVISE);
SetAt(_T("RETURN_UNADVISE"),yyRETURN_UNADVISE);
SetAt(_T("Control"),yyCONTROL);
SetAt(_T("Listener"),yyLISTENER);
SetAt(_T("Thread"),yyTHREAD);
SetAt(_T("COLUMN_SET"),yyCOLUMN_SET);
SetAt(_T("ROW_DELETE"),yyROW_DELETE);
SetAt(_T("ROW_INSERT"),yyROW_INSERT);
SetAt(_T("ROW_FIRSTCHANGE"),yyROW_FIRSTCHANGE);
SetAt(_T("ROW_ACTIVATE"),yyROW_ACTIVATE);
SetAt(_T("ROW_RELEASE"),yyROW_RELEASE);
SetAt(_T("ROW_UNDOCHANGE"),yyROW_UNDOCHANGE);
SetAt(_T("ROW_UNDOINSERT"),yyROW_UNDOINSERT);
SetAt(_T("ROW_UNDODELETE"),yyROW_UNDODELETE);
SetAt(_T("ROW_UPDATE"),yyROW_UPDATE);
SetAt(_T("ROW_RESYNCH"),yyROW_RESYNCH);
SetAt(_T("ROWSET_RELEASE"),yyROWSET_RELEASE);
SetAt(_T("ROWSET_FETCHPOSITIONCHANGE"), yyROWSET_FETCHPOSITIONCHANGE);
SetAt(_T("ROWSET_CHANGED"), yyROWSET_CHANGED);
SetAt(_T("COLUMN_RECALCULATED"), yyCOLUMN_RECALCULATED);
SetAt(_T("DBBMK_FIRST"),yyDBBMK_FIRST);
SetAt(_T("DBBMK_LAST"),yyDBBMK_LAST);
SetAt(_T("OKTODO"),yyOKTODO);
SetAt(_T("ABOUTTODO"),yyABOUTTODO);
SetAt(_T("SYNCHAFTER"),yySYNCHAFTER);
SetAt(_T("DIDEVENT"),yyDIDEVENT);
SetAt(_T("FAILEDTODO"),yyFAILEDTODO);
//HrExpected
SetAt(_T("DB_S_ENDOFROWSET"),yyDB_S_ENDOFROWSET);
SetAt(_T("DB_E_BADSTARTPOSITION"),yyDB_E_BADSTARTPOSITION);
SetAt(_T("DB_E_NOTREENTRANT"),yyDB_E_NOTREENTRANT);
SetAt(_T("DB_S_ERRORSOCCURRED"),yyDB_S_ERRORSOCCURRED);
SetAt(_T("DB_E_ERRORSOCCURRED"),yyDB_E_ERRORSOCCURRED);
SetAt(_T("E_INVALIDARG"),yyE_INVALIDARG);
SetAt(_T("DB_E_ROWSNOTRELEASED"),yyDB_E_ROWSNOTRELEASED);
SetAt(_T("DB_E_BADACCESSORHANDLE"),yyDB_E_BADACCESSORHANDLE);
SetAt(_T("DB_E_BADROWHANDLE"),yyDB_E_BADROWHANDLE);
}
KEYWORDTABLE::~KEYWORDTABLE()
{
RemoveAll();
}
// Keyword Table
KEYWORDTABLE KeywordTable;
// Identifier Table
TABLE IdentifierTable;
WCHAR LexBuf[100];
WCHAR *LexPtr;
ULONG TokenId;
ULONG IdentifierId = 1;
int yylexInit()
{
IdentifierId = 1;
IdentifierTable.RemoveAll();
return TRUE;
}
int yylex()
{
start:
// Get next char from input string
WCHAR wcChar = *yylpwzInput++;
// Check for end of input string
if (wcChar == L'\0')
{
IdentifierId = 1;
IdentifierTable.RemoveAll();
return 0;
}
if (iswspace(wcChar)) goto start;
// Check for special char and return it
if (!iswalpha(wcChar) && wcChar != L'_' && !iswdigit(wcChar))
{
char AnsiBuf[3];
WideCharToMultiByte(CP_ACP,0,LPCWSTR(&wcChar),1,AnsiBuf,sizeof(AnsiBuf),NULL,NULL);
return AnsiBuf[0];
}
// Check for digit and collect it
if (iswdigit(wcChar))
{
LexPtr = LexBuf;
*LexPtr++ = wcChar;
while (iswdigit(*yylpwzInput)) *LexPtr++ = *yylpwzInput++;
*LexPtr = L'\0';
yylval.Number = _wtol(LexBuf);
return yyNUMBER;
}
// Collect Identifier or Keyword
LexPtr = LexBuf;
*LexPtr++ = wcChar;
while (iswalnum(*yylpwzInput)|| *yylpwzInput == L'_' || *yylpwzInput == L':')
*LexPtr++ = *yylpwzInput++;
*LexPtr = L'\0';
TCHAR tszLexBuf[200];
#ifndef _UNICODE
WideCharToMultiByte(CP_ACP,0,LexBuf,-1,tszLexBuf,200,NULL,NULL);
#else
wcscpy(tszLexBuf, LexBuf);
#endif //_UNICODE
// If Keyword, return Token Id else return Identifier Id
if (KeywordTable.Lookup(tszLexBuf,TokenId))
return TokenId;
else
{
if (!IdentifierTable.Lookup(tszLexBuf,yylval.IdentifierId))
{
yylval.IdentifierId = IdentifierId++;
IdentifierTable.SetAt(tszLexBuf,yylval.IdentifierId);
}
return yyIDENTIFIERID;
}
}
*/
///////////////////////////////////////////////////////////////////////////////
// Y_TAB.C
//
///////////////////////////////////////////////////////////////////////////////
#ifndef lint
static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define yyclearin (yychar=(-1))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
#define YYPREFIX "yy"
#include "MODStandard.hpp" /*ModuleCore headers*/
#include "IRNotify.h" /*IRowsetNotify header*/
#define lint /*Removes warnings for unused labels*/
/* Input string to parse */
LPCWSTR yylpwzInput;
CExecutionManager *yypExecutionManager;
COMMANDLIST *yypCommandList;
COMMANDLISTMAP *yypCommandListMap;
CONTROLMAP *yypControlMap;
LISTENERMAP *yypListenerMap;
static LPVOID pvObjectId = NULL;
static CControl* pControl = NULL;
static DBREASON eReason = 0;
static DBEVENTPHASE ePhase = 0;
static ULONG ulCommandLevel = 1;
static ULONG cRows = 0;
static ULONG rgRowIds[MAX_ROW_COUNT];
static ULONG cColumns = 0;
static ULONG rgColumns[MAX_ROW_COUNT];
static HRESULT hrExpected = S_OK;
static ULONG cThreads = 0;
typedef union {
ULONG Number;
ULONG IdentifierId;
} YYSTYPE;
#define yyNUMBER 257
#define yyIDENTIFIERID 258
#define yyROWSET_FETCHPOSITIONCHANGE 259
#define yyROWSET_RELEASE 260
#define yyROWSET_CHANGED 261
#define yyCOLUMN_SET 262
#define yyCOLUMN_RECALCULATED 263
#define yyROW_ACTIVATE 264
#define yyROW_RELEASE 265
#define yyROW_DELETE 266
#define yyROW_FIRSTCHANGE 267
#define yyROW_INSERT 268
#define yyROW_RESYNCH 269
#define yyROW_UNDOCHANGE 270
#define yyROW_UNDOINSERT 271
#define yyROW_UNDODELETE 272
#define yyROW_UPDATE 273
#define yyOKTODO 274
#define yyABOUTTODO 275
#define yySYNCHAFTER 276
#define yyDIDEVENT 277
#define yyFAILEDTODO 278
#define yyGETDATA 279
#define yyGETORIGINALDATA 280
#define yyGETVISIBLEDATA 281
#define yyRELEASEROWSET 282
#define yyADDREFROWSET 283
#define yyGETNEXTROWS 284
#define yyRELEASEROWS 285
#define yyADDREFROWS 286
#define yyRESTARTPOSITION 287
#define yyDELETEROWS 288
#define yyINSERTROW 289
#define yySETDATA 290
#define yySEEK 291
#define yyGETROWSAT 292
#define yyGETROWSBYBOOKMARK 293
#define yyRESYNCHROWS 294
#define yyGETROWSATRATIO 295
#define yyUNDO 296
#define yyUPDATE 297
#define yyABORT 298
#define yyCOMMIT 299
#define yyADDCOLUMN 300
#define yyDROPCOLUMN 301
#define yyGETCOLUMNINFO 302
#define yyCONTROL 303
#define yyLISTENER 304
#define yyTHREAD 305
#define yyDBBMK_FIRST 306
#define yyDBBMK_LAST 307
#define yyRETURN_ACCEPT 308
#define yyRETURN_VETO 309
#define yyRETURN_EFAIL 310
#define yyRETURN_EOUTOFMEMORY 311
#define yyRETURN_EINVALIDARG 312
#define yyRETURN_UNWANTEDREASON 313
#define yyRETURN_UNWANTEDPHASE 314
#define yyRETURN_ADVISE 315
#define yyRETURN_UNADVISE 316
#define yyDB_S_ENDOFROWSET 317
#define yyDB_E_BADSTARTPOSITION 318
#define yyDB_E_NOTREENTRANT 319
#define yyDB_S_ERRORSOCCURRED 320
#define yyDB_E_ERRORSOCCURRED 321
#define yyE_INVALIDARG 322
#define yyDB_E_ROWSNOTRELEASED 323
#define yyDB_E_BADACCESSORHANDLE 324
#define yyDB_E_BADROWHANDLE 325
#define YYERRCODE 256
short yylhs[] = { -1,
1, 0, 2, 2, 4, 3, 3, 6, 5, 7,
7, 8, 8, 10, 10, 11, 12, 15, 15, 15,
17, 15, 16, 16, 16, 16, 16, 16, 16, 16,
16, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 20, 19, 18, 21, 22,
23, 23, 24, 24, 25, 25, 26, 26, 26, 26,
27, 28, 29, 29, 30, 31, 33, 32, 34, 35,
35, 36, 36, 37, 38, 39, 40, 41, 45, 45,
42, 42, 42, 42, 43, 43, 44, 44, 44, 44,
44, 44, 44, 44, 44, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
14, 14, 14, 14, 14,
};
short yylen[] = { 2,
0, 5, 1, 2, 3, 1, 2, 0, 9, 1,
2, 4, 3, 1, 2, 7, 1, 1, 4, 3,
0, 5, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 4, 4, 4, 4, 4,
4, 6, 6, 8, 4, 6, 6, 4, 6, 4,
4, 4, 4, 6, 4, 4, 4, 4, 4, 4,
6, 4, 6, 4, 4, 4, 4, 4, 1, 3,
1, 1, 3, 3, 1, 0, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1,
};
short yydefred[] = { 1,
0, 0, 0, 0, 0, 3, 0, 0, 0, 4,
6, 5, 0, 2, 7, 0, 8, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 11, 0, 0, 0, 0,
97, 98, 99, 100, 101, 102, 103, 104, 105, 0,
95, 0, 91, 0, 92, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 9, 17, 13, 0, 14, 0,
79, 80, 0, 82, 0, 58, 78, 57, 0, 56,
77, 59, 60, 61, 0, 0, 65, 0, 68, 0,
70, 0, 71, 72, 73, 0, 75, 76, 84, 85,
86, 87, 88, 12, 15, 0, 0, 0, 93, 94,
0, 89, 0, 0, 0, 0, 0, 106, 107, 108,
109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
119, 120, 0, 81, 83, 62, 63, 0, 66, 67,
69, 74, 0, 90, 0, 121, 122, 123, 124, 125,
0, 64, 0, 21, 23, 24, 25, 26, 27, 28,
29, 30, 31, 0, 16, 18, 0, 0, 0, 20,
0, 0, 19, 22,
};
short yydgoto[] = { 1,
2, 5, 9, 6, 11, 18, 44, 45, 46, 138,
139, 140, 203, 221, 235, 236, 237, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
70, 114, 115, 111, 183,
};
short yysindex[] = { 0,
0, -87, -260, -210, -123, 0, -10, -237, -94, 0,
0, 0, -180, 0, 0, 29, 0, -34, -59, 108,
111, 112, 113, 114, 139, 140, 166, 167, 169, 170,
204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
214, 215, 216, -124, 0, -30, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 3, 4, -262, -262, -238, -238, -238, -262, -238,
5, 6, 8, -294, -238, -238, 9, -238, -238, -262,
-262, -262, -262, -262, 133, 0, -122, 218, -27, -11,
0, 0, 0, 0, 0, 0, 0, 0, 0, 219,
0, 226, 0, -4, 0, 1, 2, 227, 23, 24,
225, 53, 54, 58, 59, 60, 89, 90, 91, 229,
230, 231, 232, 233, 0, 0, 0, -121, 0, 234,
0, 0, -262, 0, -262, 0, 0, 0, -211, 0,
0, 0, 0, 0, -262, 18, 0, -262, 0, -238,
0, -238, 0, 0, 0, -238, 0, 0, 0, 0,
0, 0, 0, 0, 0, -144, 235, 236, 0, 0,
237, 0, 99, 238, 100, 101, 105, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 239, 0, 0, 0, 0, -248, 0, 0,
0, 0, -253, 0, 240, 0, 0, 0, 0, 0,
241, 0, -97, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 159, 0, 0, 160, -120, -97, 0,
-119, 161, 0, 0,
};
short yyrindex[] = { 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 243, 243, 106, 106, 106, 243, 106,
0, 0, 0, 0, 106, 106, 0, 106, 106, 243,
243, 243, 243, 243, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 106,
0, 106, 0, 0, 0, 106, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0,
};
short yygindex[] = { 0,
0, 0, 0, 283, 280, 0, 0, 246, -212, 55,
-136, 0, 0, 0, 52, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, -70, -40, -117, 0,
};
#define YYTABLESIZE 293
short yytable[] = { 8,
95, 175, 137, 174, 240, 243, 116, 117, 214, 119,
234, 123, 124, 142, 125, 126, 143, 128, 129, 113,
216, 217, 218, 219, 220, 177, 234, 178, 8, 144,
14, 180, 145, 110, 112, 3, 148, 181, 118, 149,
184, 150, 151, 4, 149, 149, 179, 7, 12, 130,
131, 132, 133, 134, 101, 102, 103, 104, 105, 106,
107, 108, 109, 153, 154, 13, 149, 155, 101, 102,
103, 104, 105, 106, 107, 108, 109, 16, 101, 102,
103, 104, 105, 106, 107, 108, 109, 17, 19, 185,
215, 186, 97, 157, 159, 187, 158, 160, 161, 163,
164, 162, 149, 149, 175, 101, 102, 103, 104, 105,
106, 107, 108, 109, 188, 189, 190, 191, 192, 193,
194, 195, 196, 197, 198, 199, 200, 201, 202, 165,
167, 168, 166, 149, 149, 136, 136, 136, 136, 207,
210, 211, 208, 149, 149, 212, 96, 71, 149, 96,
72, 73, 74, 75, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 76, 77,
4, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 78, 79, 224, 80, 81,
225, 226, 227, 228, 229, 230, 231, 232, 233, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 82, 83, 84, 85, 86, 87, 88,
89, 90, 91, 92, 93, 94, 98, 135, 141, 146,
99, 100, 120, 121, 122, 127, 147, 152, 156, 169,
170, 171, 172, 173, 182, 204, 205, 206, 209, 176,
222, 238, 239, 96, 213, 244, 223, 10, 15, 96,
242, 0, 241,
};
short yycheck[] = { 123,
125, 138, 125, 125, 125, 125, 77, 78, 257, 80,
223, 306, 307, 41, 85, 86, 44, 88, 89, 258,
274, 275, 276, 277, 278, 143, 239, 145, 123, 41,
125, 149, 44, 74, 75, 123, 41, 155, 79, 44,
158, 41, 41, 304, 44, 44, 258, 258, 59, 90,
91, 92, 93, 94, 317, 318, 319, 320, 321, 322,
323, 324, 325, 41, 41, 303, 44, 44, 317, 318,
319, 320, 321, 322, 323, 324, 325, 258, 317, 318,
319, 320, 321, 322, 323, 324, 325, 59, 123, 160,
208, 162, 123, 41, 41, 166, 44, 44, 41, 41,
41, 44, 44, 44, 241, 317, 318, 319, 320, 321,
322, 323, 324, 325, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 41,
41, 41, 44, 44, 44, 258, 258, 258, 258, 41,
41, 41, 44, 44, 44, 41, 41, 40, 44, 44,
40, 40, 40, 40, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295, 296, 297, 298, 299, 300, 301, 302, 40, 40,
304, 279, 280, 281, 282, 283, 284, 285, 286, 287,
288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
298, 299, 300, 301, 302, 40, 40, 305, 40, 40,
308, 309, 310, 311, 312, 313, 314, 315, 316, 279,
280, 281, 282, 283, 284, 285, 286, 287, 288, 289,
290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
300, 301, 302, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 258, 125, 41, 41,
258, 258, 258, 258, 257, 257, 41, 41, 44, 41,
41, 41, 41, 41, 257, 41, 41, 41, 41, 46,
41, 123, 123, 41, 46, 125, 46, 5, 9, 44,
239, -1, 238,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 325
#if YYDEBUG
char *yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,"'('","')'",0,0,"','",0,"'.'",0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
"yyNUMBER","yyIDENTIFIERID","yyROWSET_FETCHPOSITIONCHANGE","yyROWSET_RELEASE",
"yyROWSET_CHANGED","yyCOLUMN_SET","yyCOLUMN_RECALCULATED","yyROW_ACTIVATE",
"yyROW_RELEASE","yyROW_DELETE","yyROW_FIRSTCHANGE","yyROW_INSERT",
"yyROW_RESYNCH","yyROW_UNDOCHANGE","yyROW_UNDOINSERT","yyROW_UNDODELETE",
"yyROW_UPDATE","yyOKTODO","yyABOUTTODO","yySYNCHAFTER","yyDIDEVENT",
"yyFAILEDTODO","yyGETDATA","yyGETORIGINALDATA","yyGETVISIBLEDATA",
"yyRELEASEROWSET","yyADDREFROWSET","yyGETNEXTROWS","yyRELEASEROWS",
"yyADDREFROWS","yyRESTARTPOSITION","yyDELETEROWS","yyINSERTROW","yySETDATA",
"yySEEK","yyGETROWSAT","yyGETROWSBYBOOKMARK","yyRESYNCHROWS","yyGETROWSATRATIO",
"yyUNDO","yyUPDATE","yyABORT","yyCOMMIT","yyADDCOLUMN","yyDROPCOLUMN",
"yyGETCOLUMNINFO","yyCONTROL","yyLISTENER","yyTHREAD","yyDBBMK_FIRST",
"yyDBBMK_LAST","yyRETURN_ACCEPT","yyRETURN_VETO","yyRETURN_EFAIL",
"yyRETURN_EOUTOFMEMORY","yyRETURN_EINVALIDARG","yyRETURN_UNWANTEDREASON",
"yyRETURN_UNWANTEDPHASE","yyRETURN_ADVISE","yyRETURN_UNADVISE",
"yyDB_S_ENDOFROWSET","yyDB_E_BADSTARTPOSITION","yyDB_E_NOTREENTRANT",
"yyDB_S_ERRORSOCCURRED","yyDB_E_ERRORSOCCURRED","yyE_INVALIDARG",
"yyDB_E_ROWSNOTRELEASED","yyDB_E_BADACCESSORHANDLE","yyDB_E_BADROWHANDLE",
};
char *yyrule[] = {
"$accept : Notification_Test",
"$$1 :",
"Notification_Test : $$1 '{' ListenerList ControlList '}'",
"ListenerList : Listener",
"ListenerList : ListenerList Listener",
"Listener : yyLISTENER yyIDENTIFIERID ';'",
"ControlList : Control",
"ControlList : ControlList Control",
"$$2 :",
"Control : '{' yyCONTROL yyIDENTIFIERID ';' $$2 '{' ControlStmtList '}' '}'",
"ControlStmtList : ControlStmt",
"ControlStmtList : ControlStmtList ControlStmt",
"ControlStmt : OLEDBMethod '{' ListenerStmtList '}'",
"ControlStmt : OLEDBMethod '{' '}'",
"ListenerStmtList : ListenerStmt",
"ListenerStmtList : ListenerStmtList ListenerStmt",
"ListenerStmt : ListenerIdentifier '.' Reason '.' Phase '.' ListenerMethod",
"ListenerIdentifier : yyIDENTIFIERID",
"ListenerMethod : ListenerReturn",
"ListenerMethod : OLEDBMethod '{' ListenerStmtList '}'",
"ListenerMethod : OLEDBMethod '{' '}'",
"$$3 :",
"ListenerMethod : yyTHREAD $$3 '{' ListenerMethod '}'",
"ListenerReturn : yyRETURN_ACCEPT",
"ListenerReturn : yyRETURN_VETO",
"ListenerReturn : yyRETURN_EFAIL",
"ListenerReturn : yyRETURN_EOUTOFMEMORY",
"ListenerReturn : yyRETURN_EINVALIDARG",
"ListenerReturn : yyRETURN_UNWANTEDREASON",
"ListenerReturn : yyRETURN_UNWANTEDPHASE",
"ListenerReturn : yyRETURN_ADVISE",
"ListenerReturn : yyRETURN_UNADVISE",
"OLEDBMethod : ReleaseRowsetMethod",
"OLEDBMethod : GetNextRows",
"OLEDBMethod : ReleaseRowsMethod",
"OLEDBMethod : RestartPositionMethod",
"OLEDBMethod : DeleteRowsMethod",
"OLEDBMethod : InsertRowMethod",
"OLEDBMethod : SetDataMethod",
"OLEDBMethod : SeekMethod",
"OLEDBMethod : GetRowsAtMethod",
"OLEDBMethod : GetRowsByBookmarkMethod",
"OLEDBMethod : ResynchRowsMethod",
"OLEDBMethod : GetRowsAtRatioMethod",
"OLEDBMethod : UndoMethod",
"OLEDBMethod : UpdateMethod",
"OLEDBMethod : AddRefRowsetMethod",
"OLEDBMethod : AddRefRowsMethod",
"OLEDBMethod : GetDataMethod",
"OLEDBMethod : GetOriginalDataMethod",
"OLEDBMethod : GetVisibleDataMethod",
"OLEDBMethod : AbortMethod",
"OLEDBMethod : CommitMethod",
"OLEDBMethod : AddColumnMethod",
"OLEDBMethod : DropColumnMethod",
"OLEDBMethod : GetColumnInfoMethod",
"ReleaseRowsMethod : yyRELEASEROWS '(' IdentifierList ')'",
"GetNextRows : yyGETNEXTROWS '(' IdentifierList ')'",
"ReleaseRowsetMethod : yyRELEASEROWSET '(' EmptyList ')'",
"RestartPositionMethod : yyRESTARTPOSITION '(' EmptyList ')'",
"DeleteRowsMethod : yyDELETEROWS '(' IdentifierList ')'",
"InsertRowMethod : yyINSERTROW '(' yyIDENTIFIERID ')'",
"InsertRowMethod : yyINSERTROW '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'",
"SetDataMethod : yySETDATA '(' yyIDENTIFIERID ',' OrdinalList ')'",
"SetDataMethod : yySETDATA '(' yyIDENTIFIERID ',' OrdinalList ',' ExpectedHRESULT ')'",
"SeekMethod : yySEEK '(' yyNUMBER ')'",
"SeekMethod : yySEEK '(' yyNUMBER ',' ExpectedHRESULT ')'",
"GetRowsAtMethod : yyGETROWSAT '(' yyDBBMK_FIRST ',' IdentifierList ')'",
"GetRowsAtMethod : yyGETROWSAT '(' yyDBBMK_FIRST ')'",
"GetRowsAtMethod : yyGETROWSAT '(' yyDBBMK_LAST ',' IdentifierList ')'",
"GetRowsAtMethod : yyGETROWSAT '(' yyDBBMK_LAST ')'",
"GetRowsByBookmarkMethod : yyGETROWSBYBOOKMARK '(' IdentifierList ')'",
"ResynchRowsMethod : yyRESYNCHROWS '(' IdentifierList ')'",
"GetRowsAtRatioMethod : yyGETROWSATRATIO '(' yyNUMBER ')'",
"GetRowsAtRatioMethod : yyGETROWSATRATIO '(' yyNUMBER ',' IdentifierList ')'",
"UndoMethod : yyUNDO '(' IdentifierList ')'",
"UpdateMethod : yyUPDATE '(' IdentifierList ')'",
"AddRefRowsMethod : yyADDREFROWS '(' IdentifierList ')'",
"AddRefRowsetMethod : yyADDREFROWSET '(' EmptyList ')'",
"GetDataMethod : yyGETDATA '(' yyIDENTIFIERID ')'",
"GetOriginalDataMethod : yyGETORIGINALDATA '(' yyIDENTIFIERID ')'",
"GetOriginalDataMethod : yyGETORIGINALDATA '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'",
"GetVisibleDataMethod : yyGETVISIBLEDATA '(' yyIDENTIFIERID ')'",
"GetVisibleDataMethod : yyGETVISIBLEDATA '(' yyIDENTIFIERID ',' ExpectedHRESULT ')'",
"AbortMethod : yyABORT '(' EmptyList ')'",
"CommitMethod : yyCOMMIT '(' EmptyList ')'",
"AddColumnMethod : yyADDCOLUMN '(' EmptyList ')'",
"DropColumnMethod : yyDROPCOLUMN '(' EmptyList ')'",
"GetColumnInfoMethod : yyGETCOLUMNINFO '(' EmptyList ')'",
"OrdinalList : yyNUMBER",
"OrdinalList : OrdinalList ',' yyNUMBER",
"IdentifierList : yyIDENTIFIERID",
"IdentifierList : EmptyList",
"IdentifierList : IdentifierList ',' yyIDENTIFIERID",
"IdentifierList : IdentifierList ',' ExpectedHRESULT",
"EmptyList : ExpectedHRESULT",
"EmptyList :",
"ExpectedHRESULT : yyDB_S_ENDOFROWSET",
"ExpectedHRESULT : yyDB_E_BADSTARTPOSITION",
"ExpectedHRESULT : yyDB_E_NOTREENTRANT",
"ExpectedHRESULT : yyDB_S_ERRORSOCCURRED",
"ExpectedHRESULT : yyDB_E_ERRORSOCCURRED",
"ExpectedHRESULT : yyE_INVALIDARG",
"ExpectedHRESULT : yyDB_E_ROWSNOTRELEASED",
"ExpectedHRESULT : yyDB_E_BADACCESSORHANDLE",
"ExpectedHRESULT : yyDB_E_BADROWHANDLE",
"Reason : yyROWSET_FETCHPOSITIONCHANGE",
"Reason : yyROWSET_RELEASE",
"Reason : yyROWSET_CHANGED",
"Reason : yyCOLUMN_SET",
"Reason : yyCOLUMN_RECALCULATED",
"Reason : yyROW_ACTIVATE",
"Reason : yyROW_RELEASE",
"Reason : yyROW_DELETE",
"Reason : yyROW_FIRSTCHANGE",
"Reason : yyROW_INSERT",
"Reason : yyROW_RESYNCH",
"Reason : yyROW_UNDOCHANGE",
"Reason : yyROW_UNDOINSERT",
"Reason : yyROW_UNDODELETE",
"Reason : yyROW_UPDATE",
"Phase : yyOKTODO",
"Phase : yyABOUTTODO",
"Phase : yySYNCHAFTER",
"Phase : yyDIDEVENT",
"Phase : yyFAILEDTODO",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short yyss[YYSTACKSIZE];
YYSTYPE yyvs[YYSTACKSIZE];
#define yystacksize YYSTACKSIZE
int yyerror(char*s)
{
return 0;
}
// Keyword Table for Parser
typedef CMap <CString, LPCTSTR, ULONG, ULONG> TABLE;
class KEYWORDTABLE : public TABLE
{
public:
KEYWORDTABLE();
~KEYWORDTABLE();
};
KEYWORDTABLE::KEYWORDTABLE()
{
SetAt(_T("IRowset::GetData"),yyGETDATA);
SetAt(_T("IRowsetUpdate::GetOriginalData"),yyGETORIGINALDATA);
SetAt(_T("IRowsetResynch::GetVisibleData"),yyGETVISIBLEDATA);
SetAt(_T("IRowsetChange::SetData"),yySETDATA);
SetAt(_T("IRowsetIndex::Seek"),yySEEK);
SetAt(_T("IRowsetChange::DeleteRows"),yyDELETEROWS);
SetAt(_T("IRowsetChange::InsertRow"),yyINSERTROW);
SetAt(_T("IRowsetUpdate::Update"),yyUPDATE);
SetAt(_T("IRowsetUpdate::Undo"),yyUNDO);
SetAt(_T("IRowset::GetNextRows"),yyGETNEXTROWS);
SetAt(_T("IRowset::ReleaseRows"),yyRELEASEROWS);
SetAt(_T("IRowset::AddRefRows"),yyADDREFROWS);
SetAt(_T("IRowset::AddRef"),yyADDREFROWSET);
SetAt(_T("IRowset::Release"),yyRELEASEROWSET);
SetAt(_T("IRowsetResynch::ResynchRows"),yyRESYNCHROWS);
SetAt(_T("IRowsetLocate::GetRowsAt"),yyGETROWSAT);
SetAt(_T("IRowsetScroll::GetRowsAtRatio"),yyGETROWSATRATIO);
SetAt(_T("IRowset::RestartPosition"),yyRESTARTPOSITION);
SetAt(_T("IRowsetLocate::GetRowsByBookmark"),yyGETROWSBYBOOKMARK);
SetAt(_T("ITransaction::Abort"), yyABORT);
SetAt(_T("ITransaction::Commit"), yyCOMMIT);
SetAt(_T("ITableDefinition::AddColumn"), yyADDCOLUMN);
SetAt(_T("ITableDefinition::DropColumn"), yyDROPCOLUMN);
SetAt(_T("IColumnsInfo::GetColumnInfo"), yyGETCOLUMNINFO);
//Listener Return values
SetAt(_T("RETURN_ACCEPT"),yyRETURN_ACCEPT);
SetAt(_T("RETURN_VETO"),yyRETURN_VETO);
SetAt(_T("RETURN_EFAIL"),yyRETURN_EFAIL);
SetAt(_T("RETURN_EOUTOFMEMORY"),yyRETURN_EOUTOFMEMORY);
SetAt(_T("RETURN_EINVALIDARG"),yyRETURN_EINVALIDARG);
SetAt(_T("RETURN_UNWANTEDREASON"),yyRETURN_UNWANTEDREASON);
SetAt(_T("RETURN_UNWANTEDPHASE"),yyRETURN_UNWANTEDPHASE);
SetAt(_T("RETURN_ADVISE"),yyRETURN_ADVISE);
SetAt(_T("RETURN_UNADVISE"),yyRETURN_UNADVISE);
SetAt(_T("Control"),yyCONTROL);
SetAt(_T("Listener"),yyLISTENER);
SetAt(_T("Thread"),yyTHREAD);
SetAt(_T("COLUMN_SET"),yyCOLUMN_SET);
SetAt(_T("ROW_DELETE"),yyROW_DELETE);
SetAt(_T("ROW_INSERT"),yyROW_INSERT);
SetAt(_T("ROW_FIRSTCHANGE"),yyROW_FIRSTCHANGE);
SetAt(_T("ROW_ACTIVATE"),yyROW_ACTIVATE);
SetAt(_T("ROW_RELEASE"),yyROW_RELEASE);
SetAt(_T("ROW_UNDOCHANGE"),yyROW_UNDOCHANGE);
SetAt(_T("ROW_UNDOINSERT"),yyROW_UNDOINSERT);
SetAt(_T("ROW_UNDODELETE"),yyROW_UNDODELETE);
SetAt(_T("ROW_UPDATE"),yyROW_UPDATE);
SetAt(_T("ROW_RESYNCH"),yyROW_RESYNCH);
SetAt(_T("ROWSET_RELEASE"),yyROWSET_RELEASE);
SetAt(_T("ROWSET_FETCHPOSITIONCHANGE"), yyROWSET_FETCHPOSITIONCHANGE);
SetAt(_T("ROWSET_CHANGED"), yyROWSET_CHANGED);
SetAt(_T("COLUMN_RECALCULATED"), yyCOLUMN_RECALCULATED);
SetAt(_T("DBBMK_FIRST"),yyDBBMK_FIRST);
SetAt(_T("DBBMK_LAST"),yyDBBMK_LAST);
SetAt(_T("OKTODO"),yyOKTODO);
SetAt(_T("ABOUTTODO"),yyABOUTTODO);
SetAt(_T("SYNCHAFTER"),yySYNCHAFTER);
SetAt(_T("DIDEVENT"),yyDIDEVENT);
SetAt(_T("FAILEDTODO"),yyFAILEDTODO);
//HrExpected
SetAt(_T("DB_S_ENDOFROWSET"),yyDB_S_ENDOFROWSET);
SetAt(_T("DB_E_BADSTARTPOSITION"),yyDB_E_BADSTARTPOSITION);
SetAt(_T("DB_E_NOTREENTRANT"),yyDB_E_NOTREENTRANT);
SetAt(_T("DB_S_ERRORSOCCURRED"),yyDB_S_ERRORSOCCURRED);
SetAt(_T("DB_E_ERRORSOCCURRED"),yyDB_E_ERRORSOCCURRED);
SetAt(_T("E_INVALIDARG"),yyE_INVALIDARG);
SetAt(_T("DB_E_ROWSNOTRELEASED"),yyDB_E_ROWSNOTRELEASED);
SetAt(_T("DB_E_BADACCESSORHANDLE"),yyDB_E_BADACCESSORHANDLE);
SetAt(_T("DB_E_BADROWHANDLE"),yyDB_E_BADROWHANDLE);
}
KEYWORDTABLE::~KEYWORDTABLE()
{
RemoveAll();
}
// Keyword Table
KEYWORDTABLE KeywordTable;
// Identifier Table
TABLE IdentifierTable;
WCHAR LexBuf[100];
WCHAR *LexPtr;
ULONG TokenId;
ULONG IdentifierId = 1;
int yylexInit()
{
IdentifierId = 1;
IdentifierTable.RemoveAll();
return TRUE;
}
int yylex()
{
start:
// Get next char from input string
WCHAR wcChar = *yylpwzInput++;
// Check for end of input string
if (wcChar == L'\0')
{
IdentifierId = 1;
IdentifierTable.RemoveAll();
return 0;
}
if (iswspace(wcChar)) goto start;
// Check for special char and return it
if (!iswalpha(wcChar) && wcChar != L'_' && !iswdigit(wcChar))
{
char AnsiBuf[3];
WideCharToMultiByte(CP_ACP,0,LPCWSTR(&wcChar),1,AnsiBuf,sizeof(AnsiBuf),NULL,NULL);
return AnsiBuf[0];
}
// Check for digit and collect it
if (iswdigit(wcChar))
{
LexPtr = LexBuf;
*LexPtr++ = wcChar;
while (iswdigit(*yylpwzInput)) *LexPtr++ = *yylpwzInput++;
*LexPtr = L'\0';
yylval.Number = _wtol(LexBuf);
return yyNUMBER;
}
// Collect Identifier or Keyword
LexPtr = LexBuf;
*LexPtr++ = wcChar;
while (iswalnum(*yylpwzInput)|| *yylpwzInput == L'_' || *yylpwzInput == L':')
*LexPtr++ = *yylpwzInput++;
*LexPtr = L'\0';
TCHAR tszLexBuf[200];
#ifndef _UNICODE
WideCharToMultiByte(CP_ACP,0,LexBuf,-1,tszLexBuf,200,NULL,NULL);
#else
wcscpy(tszLexBuf, LexBuf);
#endif //_UNICODE
// If Keyword, return Token Id else return Identifier Id
if (KeywordTable.Lookup(tszLexBuf,TokenId))
return TokenId;
else
{
if (!IdentifierTable.Lookup(tszLexBuf,yylval.IdentifierId))
{
yylval.IdentifierId = IdentifierId++;
IdentifierTable.SetAt(tszLexBuf,yylval.IdentifierId);
}
return yyIDENTIFIERID;
}
}
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse()
{
register int yym, yyn, yystate;
#if YYDEBUG
register char *yys;
extern char *getenv();
if (yys = getenv("YYDEBUG"))
{
yyn = *yys;
if (yyn >= '0' && yyn <= '9')
yydebug = yyn - '0';
}
#endif
yynerrs = 0;
yyerrflag = 0;
yychar = (-1);
yyssp = yyss;
yyvsp = yyvs;
*yyssp = yystate = 0;
yyloop:
if (yyn = yydefred[yystate]) goto yyreduce;
if (yychar < 0)
{
if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
}
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, shifting to state %d\n",
YYPREFIX, yystate, yytable[yyn]);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = yystate = yytable[yyn];
*++yyvsp = yylval;
yychar = (-1);
if (yyerrflag > 0) --yyerrflag;
goto yyloop;
}
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
yyn = yytable[yyn];
goto yyreduce;
}
if (yyerrflag) goto yyinrecovery;
#ifdef lint
goto yynewerror;
#endif
yynewerror:
yyerror("syntax error");
#ifdef lint
goto yyerrlab;
#endif
yyerrlab:
++yynerrs;
yyinrecovery:
if (yyerrflag < 3)
{
yyerrflag = 3;
for (;;)
{
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, error recovery shifting\
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = yystate = yytable[yyn];
*++yyvsp = yylval;
goto yyloop;
}
else
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: error recovery discarding state %d\n",
YYPREFIX, *yyssp);
#endif
if (yyssp <= yyss) goto yyabort;
--yyssp;
--yyvsp;
}
}
}
else
{
if (yychar == 0) goto yyabort;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
yychar = (-1);
goto yyloop;
}
yyreduce:
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, reducing by rule %d (%s)\n",
YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
yym = yylen[yyn];
yyval = yyvsp[1-yym];
switch (yyn)
{
case 1:
{ulCommandLevel = 1; }
break;
case 5:
{yypListenerMap->SetAt(yyvsp[-1].IdentifierId,new CImpIListener(yypExecutionManager));}
break;
case 8:
{
pControl = new CControl(yypExecutionManager);
pvObjectId = pControl;
ulCommandLevel = 1;
yypControlMap->SetAt(yyvsp[-1].IdentifierId,pControl);
yypCommandList = new COMMANDLIST;
yypCommandListMap->SetAt(pControl->GetThreadId(), yypCommandList);
}
break;
case 12:
{
ulCommandLevel++;
pvObjectId = pControl;
}
break;
case 13:
{
ulCommandLevel++;
pvObjectId = pControl;
}
break;
case 17:
{CImpIListener *pImpIListener;
BOOL Ok = yypListenerMap->Lookup(yyvsp[0].IdentifierId,pImpIListener);
if (!Ok) yyerror("Invalid Listener");
pvObjectId = pImpIListener;}
break;
case 18:
{
}
break;
case 19:
{
}
break;
case 20:
{
}
break;
case 21:
{ cThreads = 1; }
break;
case 22:
{
cThreads = 0;
}
break;
case 23:
{yypCommandList->AddTail(
new COMMAND(RETURN_ACCEPT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 24:
{yypCommandList->AddTail(
new COMMAND(RETURN_VETO, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 25:
{yypCommandList->AddTail(
new COMMAND(RETURN_EFAIL, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 26:
{yypCommandList->AddTail(
new COMMAND(RETURN_EOUTOFMEMORY, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 27:
{yypCommandList->AddTail(
new COMMAND(RETURN_EINVALIDARG, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 28:
{yypCommandList->AddTail(
new COMMAND(RETURN_UNWANTEDREASON, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 29:
{yypCommandList->AddTail(
new COMMAND(RETURN_UNWANTEDPHASE, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 30:
{yypCommandList->AddTail(
new COMMAND(RETURN_ADVISE, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 31:
{yypCommandList->AddTail(
new COMMAND(RETURN_UNADVISE, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase));}
break;
case 56:
{yypCommandList->AddTail(
new COMMAND(RELEASEROWS, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 57:
{yypCommandList->AddTail(
new COMMAND(GETNEXTROWS, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 58:
{yypCommandList->AddTail(
new COMMAND(RELEASEROWSET, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 59:
{yypCommandList->AddTail(
new COMMAND(RESTARTPOSITION, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 60:
{yypCommandList->AddTail(
new COMMAND(DELETEROWS, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 61:
{yypCommandList->AddTail(
new COMMAND(INSERTROW, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-1].IdentifierId)));}
break;
case 62:
{yypCommandList->AddTail(
new COMMAND(INSERTROW, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-3].IdentifierId)));}
break;
case 63:
{yypCommandList->AddTail(
new COMMAND(SETDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-3].IdentifierId), /*rgRowIds*/
cColumns, /*cColumns*/
rgColumns));}
break;
case 64:
{yypCommandList->AddTail(
new COMMAND(SETDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-5].IdentifierId), /*rgRowIds*/
cColumns, /*cColumns*/
rgColumns));}
break;
case 65:
{yypCommandList->AddTail(
new COMMAND(SEEK, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
yyvsp[-1].Number, /*cRows*/
rgRowIds));}
break;
case 66:
{yypCommandList->AddTail(
new COMMAND(SEEK, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
yyvsp[-3].Number, /*cRows*/
rgRowIds));}
break;
case 67:
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
DBBMK_FIRST));}
break;
case 68:
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
0, /*cRows*/
NULL, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
DBBMK_FIRST));}
break;
case 69:
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
DBBMK_LAST));}
break;
case 70:
{yypCommandList->AddTail(
new COMMAND(GETROWSAT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
0, /*cRows*/
NULL, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
DBBMK_LAST));}
break;
case 71:
{yypCommandList->AddTail(
new COMMAND(GETROWSBYBOOKMARK, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 72:
{yypCommandList->AddTail(
new COMMAND(RESYNCHROWS, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 73:
{yypCommandList->AddTail(
new COMMAND(GETROWSATRATIO, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
0, /*cRows*/
NULL, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
yyvsp[-1].Number));}
break;
case 74:
{yypCommandList->AddTail(
new COMMAND(GETROWSATRATIO, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds, /*rgRowIds*/
0, /*cColumns*/
NULL, /*rgColumns*/
yyvsp[-3].Number));}
break;
case 75:
{yypCommandList->AddTail(
new COMMAND(UNDO, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 76:
{yypCommandList->AddTail(
new COMMAND(UPDATE, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 77:
{yypCommandList->AddTail(
new COMMAND(ADDREFROWS, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
cRows, /*cRows*/
rgRowIds));}
break;
case 78:
{yypCommandList->AddTail(
new COMMAND(ADDREFROWSET, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 79:
{yypCommandList->AddTail(
new COMMAND(GETDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-1].IdentifierId) ));}
break;
case 80:
{yypCommandList->AddTail(
new COMMAND(GETORIGINALDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-1].IdentifierId) ));}
break;
case 81:
{yypCommandList->AddTail(
new COMMAND(GETORIGINALDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-3].IdentifierId)));}
break;
case 82:
{yypCommandList->AddTail(
new COMMAND(GETVISIBLEDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
S_OK, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-1].IdentifierId) ));}
break;
case 83:
{yypCommandList->AddTail(
new COMMAND(GETVISIBLEDATA, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected, /*hrExpected*/
1, /*cRows*/
&(yyvsp[-3].IdentifierId)));}
break;
case 84:
{yypCommandList->AddTail(
new COMMAND(ABORT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 85:
{yypCommandList->AddTail(
new COMMAND(COMMIT, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 86:
{yypCommandList->AddTail(
new COMMAND(ADDCOLUMN, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 87:
{yypCommandList->AddTail(
new COMMAND(DROPCOLUMN, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 88:
{yypCommandList->AddTail(
new COMMAND(GETCOLUMNINFO, /*eCOMMANDTYPE*/
pvObjectId, /*pvObjectId*/
ulCommandLevel, /*ulCommandLevel*/
cThreads, /*cThreads*/
eReason, /*eReason*/
ePhase, /*ePhase*/
hrExpected));}
break;
case 89:
{cColumns = 0; rgColumns[cColumns++] = yyvsp[0].Number;}
break;
case 90:
{rgColumns[cColumns++] = yyvsp[0].Number;}
break;
case 91:
{
cRows = 0;
rgRowIds[cRows++] = yyvsp[0].IdentifierId;
hrExpected = S_OK;
}
break;
case 92:
{
}
break;
case 93:
{
rgRowIds[cRows++] = yyvsp[0].IdentifierId;
}
break;
case 94:
{
}
break;
case 95:
{
cRows = 0;
cColumns = 0;
}
break;
case 96:
{
cRows = 0;
cColumns = 0;
hrExpected = S_OK;
}
break;
case 97:
{
// cRows = SIZEOF_TABLE;
hrExpected = DB_S_ENDOFROWSET;
}
break;
case 98:
{
hrExpected = DB_E_BADSTARTPOSITION;
}
break;
case 99:
{
hrExpected = DB_E_NOTREENTRANT;
}
break;
case 100:
{
hrExpected = DB_S_ERRORSOCCURRED;
}
break;
case 101:
{
hrExpected = DB_E_ERRORSOCCURRED;
}
break;
case 102:
{
hrExpected = E_INVALIDARG;
}
break;
case 103:
{
hrExpected = DB_E_ROWSNOTRELEASED;
}
break;
case 104:
{
hrExpected = DB_E_BADACCESSORHANDLE;
}
break;
case 105:
{
hrExpected = DB_E_BADROWHANDLE;
}
break;
case 106:
{eReason = DBREASON_ROWSET_FETCHPOSITIONCHANGE;}
break;
case 107:
{eReason = DBREASON_ROWSET_RELEASE;}
break;
case 108:
{eReason = DBREASON_ROWSET_CHANGED;}
break;
case 109:
{eReason = DBREASON_COLUMN_SET;}
break;
case 110:
{eReason = DBREASON_COLUMN_RECALCULATED;}
break;
case 111:
{eReason = DBREASON_ROW_ACTIVATE;}
break;
case 112:
{eReason = DBREASON_ROW_RELEASE;}
break;
case 113:
{eReason = DBREASON_ROW_DELETE;}
break;
case 114:
{eReason = DBREASON_ROW_FIRSTCHANGE;}
break;
case 115:
{eReason = DBREASON_ROW_INSERT;}
break;
case 116:
{eReason = DBREASON_ROW_RESYNCH;}
break;
case 117:
{eReason = DBREASON_ROW_UNDOCHANGE;}
break;
case 118:
{eReason = DBREASON_ROW_UNDOINSERT;}
break;
case 119:
{eReason = DBREASON_ROW_UNDODELETE;}
break;
case 120:
{eReason = DBREASON_ROW_UPDATE;}
break;
case 121:
{ePhase = DBEVENTPHASE_OKTODO;}
break;
case 122:
{ePhase = DBEVENTPHASE_ABOUTTODO;}
break;
case 123:
{ePhase = DBEVENTPHASE_SYNCHAFTER;}
break;
case 124:
{ePhase = DBEVENTPHASE_DIDEVENT;}
break;
case 125:
{ePhase = DBEVENTPHASE_FAILEDTODO;}
break;
}
yyssp -= yym;
yystate = *yyssp;
yyvsp -= yym;
yym = yylhs[yyn];
if (yystate == 0 && yym == 0)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state 0 to\
state %d\n", YYPREFIX, YYFINAL);
#endif
yystate = YYFINAL;
*++yyssp = YYFINAL;
*++yyvsp = yyval;
if (yychar < 0)
{
if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, YYFINAL, yychar, yys);
}
#endif
}
if (yychar == 0) goto yyaccept;
goto yyloop;
}
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
yystate = yytable[yyn];
else
yystate = yydgoto[yym];
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
if (yyssp >= yyss + yystacksize - 1)
{
goto yyoverflow;
}
*++yyssp = (short)yystate;
*++yyvsp = yyval;
goto yyloop;
yyoverflow:
yyerror("yacc stack overflow");
yyabort:
return (1);
yyaccept:
return (0);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_TEST_CASE_MAP(Release)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowset::Release
//
class Release : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Release,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROWSET_RELEASE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROWSET_RELEASE - DB_E_CANCELED
int Variation_4();
// @cmember ROWSET_RELEASE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROWSET_RELEASE - Veto DIDEVENT, Listener 1
int Variation_8();
// @cmember Empty
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember ROWSET_RELEASE - UNWANTED REASON
int Variation_11();
// @cmember ROWSET_RELEASE - UNWANTED PHASE - DIDEVENT
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROWSET_RELEASE - E_FAIL - All Phases
int Variation_15();
// @cmember ROWSET_RELEASE - E_OUTOFMEMORY - All Phases
int Variation_16();
// @cmember ROWSET_RELEASE - E_INVALIDARG - All Phases
int Variation_17();
// @cmember Empty
int Variation_18();
// @cmember Empty
int Variation_19();
// @cmember OTHER SCENARIOS - AddRef - Release - no notifications
int Variation_20();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_21();
// @cmember OTHER SCENARIOS - Remove Listeners
int Variation_22();
// @cmember OTHER SCENARIOS - Add Listeners
int Variation_23();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Release)
#define THE_CLASS Release
BEG_TEST_CASE(Release, CExecutionManager, L"Tests Notifications for IRowset::Release")
TEST_VARIATION(1, L"ROWSET_RELEASE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROWSET_RELEASE - DB_E_CANCELED")
TEST_VARIATION(5, L"ROWSET_RELEASE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROWSET_RELEASE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(9, L"Empty")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"ROWSET_RELEASE - UNWANTED REASON")
TEST_VARIATION(12, L"ROWSET_RELEASE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROWSET_RELEASE - E_FAIL - All Phases")
TEST_VARIATION(16, L"ROWSET_RELEASE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(17, L"ROWSET_RELEASE - E_INVALIDARG - All Phases")
TEST_VARIATION(18, L"Empty")
TEST_VARIATION(19, L"Empty")
TEST_VARIATION(20, L"OTHER SCENARIOS - AddRef - Release - no notifications")
TEST_VARIATION(21, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(22, L"OTHER SCENARIOS - Remove Listeners")
TEST_VARIATION(23, L"OTHER SCENARIOS - Add Listeners")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetNextRows)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowset::GetNextRows
//
class GetNextRows : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetNextRows,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember FETCHPOSITIONCHANGE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember FETCHPOSITIONCHANGE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember FETCHPOSITIONCHANGE - DB_E_CANCELED
int Variation_5();
// @cmember FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
int Variation_6();
// @cmember FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT - Non-notification method
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember FETCHPOSITIONCHANGE - Veto OKTODO, Listener 1
int Variation_9();
// @cmember FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 1
int Variation_10();
// @cmember FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 1
int Variation_11();
// @cmember FETCHPOSITIONCHANGE - Veto DIDEVENT, Listener 1
int Variation_12();
// @cmember FETCHPOSITIONCHANGE - Veto FAILEDTODO, Listener 1
int Variation_13();
// @cmember FETCHPOSITIONCHANGE - Veto OKTODO, Listener 2
int Variation_14();
// @cmember FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 2
int Variation_15();
// @cmember FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 3
int Variation_16();
// @cmember Empty
int Variation_17();
// @cmember Empty
int Variation_18();
// @cmember FETCHPOSITIONCHANGE - UNWANTED REASON
int Variation_19();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
int Variation_20();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
int Variation_21();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
int Variation_22();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDENVENT
int Variation_23();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
int Variation_24();
// @cmember Empty
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember FETCHPOSITIONCHANGE - E_FAIL - All Phases
int Variation_27();
// @cmember FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
int Variation_28();
// @cmember FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
int Variation_29();
// @cmember Empty
int Variation_30();
// @cmember Empty
int Variation_31();
// @cmember ROW_ACTIVATE - SINGLEROW - Accept all phases
int Variation_32();
// @cmember ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
int Variation_33();
// @cmember Empty
int Variation_34();
// @cmember Empty
int Variation_35();
// @cmember ROW_ACTIVATE - DB_E_CANCELED
int Variation_36();
// @cmember ROW_ACTIVATE - DB_E_NOTREENTRANT
int Variation_37();
// @cmember Empty
int Variation_38();
// @cmember Empty
int Variation_39();
// @cmember ROW_ACTIVATE - Veto DIDEVENT, Listener 1
int Variation_40();
// @cmember Empty
int Variation_41();
// @cmember Empty
int Variation_42();
// @cmember ROW_ACTIVATE - UNWANTED REASON
int Variation_43();
// @cmember ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
int Variation_44();
// @cmember Empty
int Variation_45();
// @cmember Empty
int Variation_46();
// @cmember ROW_ACTIVATE - E_FAIL - All Phases
int Variation_47();
// @cmember ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
int Variation_48();
// @cmember ROW_ACTIVATE - E_INVALIDARG - All Phases
int Variation_49();
// @cmember Empty
int Variation_50();
// @cmember Empty
int Variation_51();
// @cmember OTHER SCENARIOS - Fetch no rows - no notifications
int Variation_52();
// @cmember OTHER SCENARIOS - Fetch A, Fetch A again
int Variation_53();
// @cmember OTHER SCENARIOS - Fetch A, Fetch A,B
int Variation_54();
// @cmember OTHER SCENARIOS - Fetch A, ReleaseRows A, Fetch A
int Variation_55();
// @cmember Empty
int Variation_56();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more than in rowset
int Variation_57();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more at end of rowset
int Variation_58();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - Stepping backward
int Variation_59();
// @cmember Empty
int Variation_60();
// @cmember OTHER SCENARIOS - DB_E_BADSTARTPOSITION
int Variation_61();
// @cmember OTHER SCENARIOS - E_INVALIDARG
int Variation_62();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_63();
// @cmember OTHER SCENARIOS - Remove Listeners
int Variation_64();
// @cmember OTHER SCENARIOS - Add Listeners
int Variation_65();
// @cmember OTHER SCENARIOS - GetData
int Variation_66();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetNextRows)
#define THE_CLASS GetNextRows
BEG_TEST_CASE(GetNextRows, CExecutionManager, L"Tests Notifications for IRowset::GetNextRows")
TEST_VARIATION(1, L"FETCHPOSITIONCHANGE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"FETCHPOSITIONCHANGE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"FETCHPOSITIONCHANGE - DB_E_CANCELED")
TEST_VARIATION(6, L"FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT")
TEST_VARIATION(7, L"FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT - Non-notification method")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"FETCHPOSITIONCHANGE - Veto OKTODO, Listener 1")
TEST_VARIATION(10, L"FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 1")
TEST_VARIATION(11, L"FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 1")
TEST_VARIATION(12, L"FETCHPOSITIONCHANGE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(13, L"FETCHPOSITIONCHANGE - Veto FAILEDTODO, Listener 1")
TEST_VARIATION(14, L"FETCHPOSITIONCHANGE - Veto OKTODO, Listener 2")
TEST_VARIATION(15, L"FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 2")
TEST_VARIATION(16, L"FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 3")
TEST_VARIATION(17, L"Empty")
TEST_VARIATION(18, L"Empty")
TEST_VARIATION(19, L"FETCHPOSITIONCHANGE - UNWANTED REASON")
TEST_VARIATION(20, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO")
TEST_VARIATION(21, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(22, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(23, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDENVENT")
TEST_VARIATION(24, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(25, L"Empty")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"FETCHPOSITIONCHANGE - E_FAIL - All Phases")
TEST_VARIATION(28, L"FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(29, L"FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases")
TEST_VARIATION(30, L"Empty")
TEST_VARIATION(31, L"Empty")
TEST_VARIATION(32, L"ROW_ACTIVATE - SINGLEROW - Accept all phases")
TEST_VARIATION(33, L"ROW_ACTIVATE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(34, L"Empty")
TEST_VARIATION(35, L"Empty")
TEST_VARIATION(36, L"ROW_ACTIVATE - DB_E_CANCELED")
TEST_VARIATION(37, L"ROW_ACTIVATE - DB_E_NOTREENTRANT")
TEST_VARIATION(38, L"Empty")
TEST_VARIATION(39, L"Empty")
TEST_VARIATION(40, L"ROW_ACTIVATE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(41, L"Empty")
TEST_VARIATION(42, L"Empty")
TEST_VARIATION(43, L"ROW_ACTIVATE - UNWANTED REASON")
TEST_VARIATION(44, L"ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(45, L"Empty")
TEST_VARIATION(46, L"Empty")
TEST_VARIATION(47, L"ROW_ACTIVATE - E_FAIL - All Phases")
TEST_VARIATION(48, L"ROW_ACTIVATE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(49, L"ROW_ACTIVATE - E_INVALIDARG - All Phases")
TEST_VARIATION(50, L"Empty")
TEST_VARIATION(51, L"Empty")
TEST_VARIATION(52, L"OTHER SCENARIOS - Fetch no rows - no notifications")
TEST_VARIATION(53, L"OTHER SCENARIOS - Fetch A, Fetch A again")
TEST_VARIATION(54, L"OTHER SCENARIOS - Fetch A, Fetch A,B")
TEST_VARIATION(55, L"OTHER SCENARIOS - Fetch A, ReleaseRows A, Fetch A")
TEST_VARIATION(56, L"Empty")
TEST_VARIATION(57, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more than in rowset")
TEST_VARIATION(58, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more at end of rowset")
TEST_VARIATION(59, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - Stepping backward")
TEST_VARIATION(60, L"Empty")
TEST_VARIATION(61, L"OTHER SCENARIOS - DB_E_BADSTARTPOSITION")
TEST_VARIATION(62, L"OTHER SCENARIOS - E_INVALIDARG")
TEST_VARIATION(63, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(64, L"OTHER SCENARIOS - Remove Listeners")
TEST_VARIATION(65, L"OTHER SCENARIOS - Add Listeners")
TEST_VARIATION(66, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ReleaseRows)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowset::ReleaseRows
//
class ReleaseRows : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ReleaseRows,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_RELEASE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_RELEASE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember ROW_RELEASE - DB_E_CANCELED - Accept all phases
int Variation_5();
// @cmember ROW_RELEASE - DB_E_NOTREENTRANT - Accept all phases
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember ROW_RELEASE - Veto DIDEVENT, Listener 2
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Empty
int Variation_11();
// @cmember ROW_RELEASE - UNWANTED REASON
int Variation_12();
// @cmember ROW_RELEASE - UNWANTED PHASE - DIDEVENT
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember Empty
int Variation_15();
// @cmember ROW_RELEASE - E_FAIL - All Phases
int Variation_16();
// @cmember ROW_RELEASE - E_OUTOFMEMORY - All Phases
int Variation_17();
// @cmember ROW_RELEASE - E_INVALIDARG - All Phases
int Variation_18();
// @cmember Empty
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember OTHER SCENARIOS - Release 0 rows
int Variation_21();
// @cmember OTHER SCENARIOS - AddRef Row, ReleaseRows
int Variation_22();
// @cmember OTHER SCENARIOS - ReleaseRow, ReleaseRow
int Variation_23();
// @cmember OTHER SCENARIOS - ReleaseRows [valid, invalid]
int Variation_24();
// @cmember Empty
int Variation_25();
// @cmember OTHER SCENARIOS - DBROWSTATUS_S_PENDINGCHANGES
int Variation_26();
// @cmember OTHER SCENARIOS - E_INVALIDARG
int Variation_27();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_28();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_29();
// @cmember OTHER SCENARIOS - GetData
int Variation_30();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(ReleaseRows)
#define THE_CLASS ReleaseRows
BEG_TEST_CASE(ReleaseRows, CExecutionManager, L"Tests Notifications for IRowset::ReleaseRows")
TEST_VARIATION(1, L"ROW_RELEASE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_RELEASE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"ROW_RELEASE - DB_E_CANCELED - Accept all phases")
TEST_VARIATION(6, L"ROW_RELEASE - DB_E_NOTREENTRANT - Accept all phases")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"ROW_RELEASE - Veto DIDEVENT, Listener 2")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Empty")
TEST_VARIATION(12, L"ROW_RELEASE - UNWANTED REASON")
TEST_VARIATION(13, L"ROW_RELEASE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"Empty")
TEST_VARIATION(16, L"ROW_RELEASE - E_FAIL - All Phases")
TEST_VARIATION(17, L"ROW_RELEASE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(18, L"ROW_RELEASE - E_INVALIDARG - All Phases")
TEST_VARIATION(19, L"Empty")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"OTHER SCENARIOS - Release 0 rows")
TEST_VARIATION(22, L"OTHER SCENARIOS - AddRef Row, ReleaseRows")
TEST_VARIATION(23, L"OTHER SCENARIOS - ReleaseRow, ReleaseRow")
TEST_VARIATION(24, L"OTHER SCENARIOS - ReleaseRows [valid, invalid]")
TEST_VARIATION(25, L"Empty")
TEST_VARIATION(26, L"OTHER SCENARIOS - DBROWSTATUS_S_PENDINGCHANGES")
TEST_VARIATION(27, L"OTHER SCENARIOS - E_INVALIDARG")
TEST_VARIATION(28, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(29, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(30, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(RestartPosition)
//--------------------------------------------------------------------
// @class Tests Notificatons for IRowset::RestartPosition
//
class RestartPosition : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(RestartPosition,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember FETCHPOSITIONCHANGE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember FETCHPOSITIONCHANGE - DB_E_CANCELED
int Variation_4();
// @cmember FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember FETCHPOSITIONCHANGE - Veto OKTODO
int Variation_8();
// @cmember FETCHPOSITIONCHANGE - Veto ABOUTTODO
int Variation_9();
// @cmember FETCHPOSITIONCHANGE - Veto SYNCHAFTER
int Variation_10();
// @cmember FETCHPOSITIONCHANGE - Veto DIDEVENT
int Variation_11();
// @cmember FETCHPOSITIONCHANGE - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember FETCHPOSITIONCHANGE - UNWANTED REASON
int Variation_15();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
int Variation_16();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
int Variation_17();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
int Variation_18();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT
int Variation_19();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember FETCHPOSITIONCHANGE - E_FAIL - All Phases
int Variation_23();
// @cmember FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember ROWSET_CHANGED - Accept all phases
int Variation_28();
// @cmember Empty
int Variation_29();
// @cmember Empty
int Variation_30();
// @cmember ROWSET_CHANGED - DB_E_CANCELED
int Variation_31();
// @cmember ROWSET_CHANGED - DB_E_NOTREENTRANT
int Variation_32();
// @cmember Empty
int Variation_33();
// @cmember Empty
int Variation_34();
// @cmember ROWSET_CHANGED - Veto OKTODO
int Variation_35();
// @cmember ROWSET_CHANGED - Veto ABOUTTODO
int Variation_36();
// @cmember ROWSET_CHANGED - Veto SYNCHAFTER
int Variation_37();
// @cmember ROWSET_CHANGED - Veto DIDEVENT
int Variation_38();
// @cmember ROWSET_CHANGED - Veto FAILEDTODO
int Variation_39();
// @cmember Empty
int Variation_40();
// @cmember Empty
int Variation_41();
// @cmember ROWSET_CHANGED - UNWANTED REASON
int Variation_42();
// @cmember ROWSET_CHANGED - UNWANTED PHASE OKTODO
int Variation_43();
// @cmember ROWSET_CHANGED - UNWANTED PHASE ABOUTTODO
int Variation_44();
// @cmember ROWSET_CHANGED - UNWANTED PHASE SYNCHAFTER
int Variation_45();
// @cmember ROWSET_CHANGED - UNWANTED PHASE DIDEVENT
int Variation_46();
// @cmember ROWSET_CHANGED - UNWANTED PHASE FAILEDTODO
int Variation_47();
// @cmember Empty
int Variation_48();
// @cmember Empty
int Variation_49();
// @cmember ROWSET_CHANGED - E_FAIL - All Phases
int Variation_50();
// @cmember ROWSET_CHANGED - E_OUTOFMEMORY - All Phases
int Variation_51();
// @cmember ROWSET_CHANGED - E_INVALIDARG - All Phases
int Variation_52();
// @cmember Empty
int Variation_53();
// @cmember Empty
int Variation_54();
// @cmember OTHER SCENARIOS - RestartPosition
int Variation_55();
// @cmember OTHER SCENARIOS - GetNextRows - RestartPosition - RestartPosition
int Variation_56();
// @cmember Empty
int Variation_57();
// @cmember OTHER SCENARIOS - DB_E_ROWSNOTRELEASED
int Variation_58();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_59();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_60();
// @cmember OTHER SCENARIOS - GetData
int Variation_61();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(RestartPosition)
#define THE_CLASS RestartPosition
BEG_TEST_CASE(RestartPosition, CExecutionManager, L"Tests Notificatons for IRowset::RestartPosition")
TEST_VARIATION(1, L"FETCHPOSITIONCHANGE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"FETCHPOSITIONCHANGE - DB_E_CANCELED")
TEST_VARIATION(5, L"FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"FETCHPOSITIONCHANGE - Veto OKTODO")
TEST_VARIATION(9, L"FETCHPOSITIONCHANGE - Veto ABOUTTODO")
TEST_VARIATION(10, L"FETCHPOSITIONCHANGE - Veto SYNCHAFTER")
TEST_VARIATION(11, L"FETCHPOSITIONCHANGE - Veto DIDEVENT")
TEST_VARIATION(12, L"FETCHPOSITIONCHANGE - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"FETCHPOSITIONCHANGE - UNWANTED REASON")
TEST_VARIATION(16, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO")
TEST_VARIATION(17, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(18, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(19, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(20, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"FETCHPOSITIONCHANGE - E_FAIL - All Phases")
TEST_VARIATION(24, L"FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"ROWSET_CHANGED - Accept all phases")
TEST_VARIATION(29, L"Empty")
TEST_VARIATION(30, L"Empty")
TEST_VARIATION(31, L"ROWSET_CHANGED - DB_E_CANCELED")
TEST_VARIATION(32, L"ROWSET_CHANGED - DB_E_NOTREENTRANT")
TEST_VARIATION(33, L"Empty")
TEST_VARIATION(34, L"Empty")
TEST_VARIATION(35, L"ROWSET_CHANGED - Veto OKTODO")
TEST_VARIATION(36, L"ROWSET_CHANGED - Veto ABOUTTODO")
TEST_VARIATION(37, L"ROWSET_CHANGED - Veto SYNCHAFTER")
TEST_VARIATION(38, L"ROWSET_CHANGED - Veto DIDEVENT")
TEST_VARIATION(39, L"ROWSET_CHANGED - Veto FAILEDTODO")
TEST_VARIATION(40, L"Empty")
TEST_VARIATION(41, L"Empty")
TEST_VARIATION(42, L"ROWSET_CHANGED - UNWANTED REASON")
TEST_VARIATION(43, L"ROWSET_CHANGED - UNWANTED PHASE OKTODO")
TEST_VARIATION(44, L"ROWSET_CHANGED - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(45, L"ROWSET_CHANGED - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(46, L"ROWSET_CHANGED - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(47, L"ROWSET_CHANGED - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(48, L"Empty")
TEST_VARIATION(49, L"Empty")
TEST_VARIATION(50, L"ROWSET_CHANGED - E_FAIL - All Phases")
TEST_VARIATION(51, L"ROWSET_CHANGED - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(52, L"ROWSET_CHANGED - E_INVALIDARG - All Phases")
TEST_VARIATION(53, L"Empty")
TEST_VARIATION(54, L"Empty")
TEST_VARIATION(55, L"OTHER SCENARIOS - RestartPosition")
TEST_VARIATION(56, L"OTHER SCENARIOS - GetNextRows - RestartPosition - RestartPosition")
TEST_VARIATION(57, L"Empty")
TEST_VARIATION(58, L"OTHER SCENARIOS - DB_E_ROWSNOTRELEASED")
TEST_VARIATION(59, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(60, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(61, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Seek)
//--------------------------------------------------------------------
// @class Test Notifications for IRowsetIndex::Seek
//
class Seek : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Seek,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember FETCHPOSITIONCHANGE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember FETCHPOSITIONCHANGE - DB_E_CANCELED
int Variation_4();
// @cmember FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember FETCHPOSITIONCHANGE - Veto OKTODO
int Variation_8();
// @cmember FETCHPOSITIONCHANGE - Veto ABOUTTODO
int Variation_9();
// @cmember FETCHPOSITIONCHANGE - Veto SYNCHAFTER
int Variation_10();
// @cmember FETCHPOSITIONCHANGE - Veto DIDEVENT
int Variation_11();
// @cmember FETCHPOSITIONCHANGE - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember FETCHPOSITIONCHANGE - UNWANTED REASON
int Variation_15();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
int Variation_16();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
int Variation_17();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
int Variation_18();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT
int Variation_19();
// @cmember FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember FETCHPOSITIONCHANGE - E_FAIL - All Phases
int Variation_23();
// @cmember FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
int Variation_28();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_29();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_30();
// @cmember OTHER SCENARIOS - GetData
int Variation_31();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Seek)
#define THE_CLASS Seek
BEG_TEST_CASE(Seek, CExecutionManager, L"Test Notifications for IRowsetIndex::Seek")
TEST_VARIATION(1, L"FETCHPOSITIONCHANGE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"FETCHPOSITIONCHANGE - DB_E_CANCELED")
TEST_VARIATION(5, L"FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"FETCHPOSITIONCHANGE - Veto OKTODO")
TEST_VARIATION(9, L"FETCHPOSITIONCHANGE - Veto ABOUTTODO")
TEST_VARIATION(10, L"FETCHPOSITIONCHANGE - Veto SYNCHAFTER")
TEST_VARIATION(11, L"FETCHPOSITIONCHANGE - Veto DIDEVENT")
TEST_VARIATION(12, L"FETCHPOSITIONCHANGE - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"FETCHPOSITIONCHANGE - UNWANTED REASON")
TEST_VARIATION(16, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO")
TEST_VARIATION(17, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(18, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(19, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(20, L"FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"FETCHPOSITIONCHANGE - E_FAIL - All Phases")
TEST_VARIATION(24, L"FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"OTHER SCENARIOS - DB_E_BADACCESSORHANDLE")
TEST_VARIATION(29, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(30, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(31, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetRowsAt)
//--------------------------------------------------------------------
// @class Tests Notificatons for IRowsetLocate::GetRowsAt
//
class GetRowsAt : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetRowsAt,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_ACTIVATE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember ROW_ACTIVATE - DB_E_CANCELED
int Variation_5();
// @cmember ROW_ACTIVATE - DB_E_NOTREENTRANT
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember ROW_ACTIVATE - Veto DIDEVENT, Listener 1
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Empty
int Variation_11();
// @cmember ROW_ACTIVATE - UNWANTED REASON
int Variation_12();
// @cmember ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember Empty
int Variation_15();
// @cmember ROW_ACTIVATE - E_FAIL - All Phases
int Variation_16();
// @cmember ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
int Variation_17();
// @cmember ROW_ACTIVATE - E_INVALIDARG - All Phases
int Variation_18();
// @cmember Empty
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember OTHER SCENARIOS - Get same row twice
int Variation_21();
// @cmember OTHER SCENARIOS - DB_E_BADSTARTPOSITION
int Variation_22();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_23();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - more rows than are in the rowset
int Variation_24();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset
int Variation_25();
// @cmember OTHER SCENARIOS - no rows at head of rowset
int Variation_26();
// @cmember OTHER SCENARIOS - no rows at end of rowset
int Variation_27();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_28();
// @cmember OTHER SCENARIOS - GetData
int Variation_29();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetRowsAt)
#define THE_CLASS GetRowsAt
BEG_TEST_CASE(GetRowsAt, CExecutionManager, L"Tests Notificatons for IRowsetLocate::GetRowsAt")
TEST_VARIATION(1, L"ROW_ACTIVATE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_ACTIVATE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"ROW_ACTIVATE - DB_E_CANCELED")
TEST_VARIATION(6, L"ROW_ACTIVATE - DB_E_NOTREENTRANT")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"ROW_ACTIVATE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Empty")
TEST_VARIATION(12, L"ROW_ACTIVATE - UNWANTED REASON")
TEST_VARIATION(13, L"ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"Empty")
TEST_VARIATION(16, L"ROW_ACTIVATE - E_FAIL - All Phases")
TEST_VARIATION(17, L"ROW_ACTIVATE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(18, L"ROW_ACTIVATE - E_INVALIDARG - All Phases")
TEST_VARIATION(19, L"Empty")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"OTHER SCENARIOS - Get same row twice")
TEST_VARIATION(22, L"OTHER SCENARIOS - DB_E_BADSTARTPOSITION")
TEST_VARIATION(23, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(24, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - more rows than are in the rowset")
TEST_VARIATION(25, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset")
TEST_VARIATION(26, L"OTHER SCENARIOS - no rows at head of rowset")
TEST_VARIATION(27, L"OTHER SCENARIOS - no rows at end of rowset")
TEST_VARIATION(28, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(29, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetRowsByBookmark)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetLocate::GetRowsbyBookmark
//
class GetRowsByBookmark : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetRowsByBookmark,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_ACTIVATE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember ROW_ACTIVATE - DB_E_CANCELED
int Variation_5();
// @cmember ROW_ACTIVATE - DB_E_NOTREENTRANT
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember ROW_ACTIVATE - Veto DIDEVENT, Listener 1
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Empty
int Variation_11();
// @cmember ROW_ACTIVATE - UNWANTED REASON
int Variation_12();
// @cmember ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember Empty
int Variation_15();
// @cmember ROW_ACTIVATE - E_FAIL - All Phases
int Variation_16();
// @cmember ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
int Variation_17();
// @cmember ROW_ACTIVATE - E_INVALIDARG - All Phases
int Variation_18();
// @cmember Empty
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember OTHER SCENARIOS - Get no rows
int Variation_21();
// @cmember OTHER SCENARIOS - Get same row twice
int Variation_22();
// @cmember OTHER SCENARIOS - E_INVALIDARG
int Variation_23();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_24();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_25();
// @cmember OTHER SCENARIOS - GetData
int Variation_26();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetRowsByBookmark)
#define THE_CLASS GetRowsByBookmark
BEG_TEST_CASE(GetRowsByBookmark, CExecutionManager, L"Tests Notifications for IRowsetLocate::GetRowsbyBookmark")
TEST_VARIATION(1, L"ROW_ACTIVATE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_ACTIVATE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"ROW_ACTIVATE - DB_E_CANCELED")
TEST_VARIATION(6, L"ROW_ACTIVATE - DB_E_NOTREENTRANT")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"ROW_ACTIVATE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Empty")
TEST_VARIATION(12, L"ROW_ACTIVATE - UNWANTED REASON")
TEST_VARIATION(13, L"ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"Empty")
TEST_VARIATION(16, L"ROW_ACTIVATE - E_FAIL - All Phases")
TEST_VARIATION(17, L"ROW_ACTIVATE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(18, L"ROW_ACTIVATE - E_INVALIDARG - All Phases")
TEST_VARIATION(19, L"Empty")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"OTHER SCENARIOS - Get no rows")
TEST_VARIATION(22, L"OTHER SCENARIOS - Get same row twice")
TEST_VARIATION(23, L"OTHER SCENARIOS - E_INVALIDARG")
TEST_VARIATION(24, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(25, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(26, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetRowsAtRatio)
//--------------------------------------------------------------------
// @class Test Nofications for IRowsetScroll::GetRowsAtRatio
//
class GetRowsAtRatio : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetRowsAtRatio,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_ACTIVATE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember Empty
int Variation_4();
// @cmember ROW_ACTIVATE - DB_E_CANCELED
int Variation_5();
// @cmember ROW_ACTIVATE - DB_E_NOTREENTRANT
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember Empty
int Variation_8();
// @cmember ROW_ACTIVATE - Veto DIDEVENT, Listener 1
int Variation_9();
// @cmember Empty
int Variation_10();
// @cmember Empty
int Variation_11();
// @cmember ROW_ACTIVATE - UNWANTED REASON
int Variation_12();
// @cmember ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember Empty
int Variation_15();
// @cmember ROW_ACTIVATE - E_FAIL - All Phases
int Variation_16();
// @cmember ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
int Variation_17();
// @cmember ROW_ACTIVATE - E_INVALIDARG - All Phases
int Variation_18();
// @cmember Empty
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember OTHER SCENARIOS - No rows
int Variation_21();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET 1 more than rowset
int Variation_22();
// @cmember OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset
int Variation_23();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_24();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_25();
// @cmember OTHER SCENARIOS - GetData
int Variation_26();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetRowsAtRatio)
#define THE_CLASS GetRowsAtRatio
BEG_TEST_CASE(GetRowsAtRatio, CExecutionManager, L"Test Nofications for IRowsetScroll::GetRowsAtRatio")
TEST_VARIATION(1, L"ROW_ACTIVATE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_ACTIVATE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"Empty")
TEST_VARIATION(5, L"ROW_ACTIVATE - DB_E_CANCELED")
TEST_VARIATION(6, L"ROW_ACTIVATE - DB_E_NOTREENTRANT")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"Empty")
TEST_VARIATION(9, L"ROW_ACTIVATE - Veto DIDEVENT, Listener 1")
TEST_VARIATION(10, L"Empty")
TEST_VARIATION(11, L"Empty")
TEST_VARIATION(12, L"ROW_ACTIVATE - UNWANTED REASON")
TEST_VARIATION(13, L"ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"Empty")
TEST_VARIATION(16, L"ROW_ACTIVATE - E_FAIL - All Phases")
TEST_VARIATION(17, L"ROW_ACTIVATE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(18, L"ROW_ACTIVATE - E_INVALIDARG - All Phases")
TEST_VARIATION(19, L"Empty")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"OTHER SCENARIOS - No rows")
TEST_VARIATION(22, L"OTHER SCENARIOS - DB_S_ENDOFROWSET 1 more than rowset")
TEST_VARIATION(23, L"OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset")
TEST_VARIATION(24, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(25, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(26, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(DeleteRows)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetChange::DeleteRows
//
class DeleteRows : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(DeleteRows,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_DELETE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_DELETE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_DELETE - MULTIPLEROWS - DB_E_CANCELED
int Variation_4();
// @cmember ROW_DELETE - SINGLEROW - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto OKTODO Listener 1
int Variation_8();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1
int Variation_9();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto SYNCHAFTER Listener 1
int Variation_10();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto DIDEVENT Listener 2
int Variation_11();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - Veto FAILEDTODO Listener 2
int Variation_12();
// @cmember OTHER SCENARIOS - Add/Remove Listeners - SINGLEROW
int Variation_13();
// @cmember OTHER SCENARIOS - GetData - SINGLEROW
int Variation_14();
// @cmember ROW_DELETE - SINGLEROW - UNWANTED REASON
int Variation_15();
// @cmember ROW_DELETE - SINGLEROW - UNWANTED PHASE OKTODO
int Variation_16();
// @cmember ROW_DELETE - SINGLEROW - UNWANTED PHASE ABOUTTODO
int Variation_17();
// @cmember ROW_DELETE - SINGLEROW - UNWANTED PHASE SYNCHAFTER
int Variation_18();
// @cmember ROW_DELETE - SINGLEROW - UNWANTED PHASE DIDEVENT
int Variation_19();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - UNWANTED PHASE FAILEDTODO
int Variation_20();
// @cmember OTHER SCENARIOS - DBROWSTATUS_DELETED - SINGLEROW
int Variation_21();
// @cmember ROW_DELETE - SINGLEROW - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases
int Variation_22();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_INVALIDARG - All Phases
int Variation_25();
// @cmember ROW_DELETE - SINGLEROW - E_OUTOFMEMORY - All Phases
int Variation_26();
// @cmember ROW_DELETE - SINGLEROW - E_INVALIDARG - All Phases
int Variation_27();
// @cmember OTHER SCENARIOS - Delete no rows - Delete MULTIPLEROWS
int Variation_28();
// @cmember OTHER SCENARIOS - DBROWSTATUS_DELETED - MULTIPLEROWS
int Variation_29();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_30();
// @cmember OTHER SCENARIOS - Add/Remove Listeners - MULTIPLEROWS
int Variation_31();
// @cmember OTHER SCENARIOS - GetData - MULTIPLEROWS
int Variation_32();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(DeleteRows)
#define THE_CLASS DeleteRows
BEG_TEST_CASE(DeleteRows, CExecutionManager, L"Tests Notifications for IRowsetChange::DeleteRows")
TEST_VARIATION(1, L"ROW_DELETE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_DELETE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_DELETE - MULTIPLEROWS - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_DELETE - SINGLEROW - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_DELETE - MULTIPLEROWS - Veto OKTODO Listener 1")
TEST_VARIATION(9, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1")
TEST_VARIATION(10, L"ROW_DELETE - MULTIPLEROWS - Veto SYNCHAFTER Listener 1")
TEST_VARIATION(11, L"ROW_DELETE - MULTIPLEROWS - Veto DIDEVENT Listener 2")
TEST_VARIATION(12, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - Veto FAILEDTODO Listener 2")
TEST_VARIATION(13, L"OTHER SCENARIOS - Add/Remove Listeners - SINGLEROW")
TEST_VARIATION(14, L"OTHER SCENARIOS - GetData - SINGLEROW")
TEST_VARIATION(15, L"ROW_DELETE - SINGLEROW - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_DELETE - SINGLEROW - UNWANTED PHASE OKTODO")
TEST_VARIATION(17, L"ROW_DELETE - SINGLEROW - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(18, L"ROW_DELETE - SINGLEROW - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(19, L"ROW_DELETE - SINGLEROW - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(20, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(21, L"OTHER SCENARIOS - DBROWSTATUS_DELETED - SINGLEROW")
TEST_VARIATION(22, L"ROW_DELETE - SINGLEROW - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases")
TEST_VARIATION(23, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"ROW_DELETE - SINGLEROW - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(27, L"ROW_DELETE - SINGLEROW - E_INVALIDARG - All Phases")
TEST_VARIATION(28, L"OTHER SCENARIOS - Delete no rows - Delete MULTIPLEROWS")
TEST_VARIATION(29, L"OTHER SCENARIOS - DBROWSTATUS_DELETED - MULTIPLEROWS")
TEST_VARIATION(30, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(31, L"OTHER SCENARIOS - Add/Remove Listeners - MULTIPLEROWS")
TEST_VARIATION(32, L"OTHER SCENARIOS - GetData - MULTIPLEROWS")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(DeleteRows_Bufferred)
//--------------------------------------------------------------------
// @class Test Notifications for IRowsetChange::DeleteRows in Buffered Mode
//
class DeleteRows_Bufferred : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(DeleteRows_Bufferred,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_DELETE - SINGLEROW - Accept all phases
int Variation_1();
// @cmember ROW_DELETE - MULTIPLEROWS - Accept all phases
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_DELETE - DB_E_CANCELED
int Variation_4();
// @cmember ROW_DELETE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_DELETE - Veto OKTODO Listener 1
int Variation_8();
// @cmember ROW_DELETE - Veto ABOUTTODO Listener 1
int Variation_9();
// @cmember ROW_DELETE - Veto SYNCHAFTER Listener 1
int Variation_10();
// @cmember ROW_DELETE - Veto DIDEVENT Listener 2
int Variation_11();
// @cmember ROW_DELETE - Veto FAILEDTODO Listener 2
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_DELETE - UNWANTED REASON
int Variation_15();
// @cmember ROW_DELETE - UNWANTED PHASE OKTODO
int Variation_16();
// @cmember ROW_DELETE - UNWANTED PHASE ABOUTTODO
int Variation_17();
// @cmember ROW_DELETE - UNWANTED PHASE SYNCHAFTER
int Variation_18();
// @cmember ROW_DELETE - UNWANTED PHASE DIDEVENT
int Variation_19();
// @cmember ROW_DELETE - UNWANTED PHASE FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_DELETE - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_DELETE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_DELETE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember OTHER SCENARIOS - Delete no rows
int Variation_28();
// @cmember OTHER SCENARIOS - DBROWSTATUS_DELETED
int Variation_29();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_30();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_31();
// @cmember OTHER SCENARIOS - GetData
int Variation_32();
// @cmember OTHER SCENARIOS - GetOriginalData
int Variation_33();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(DeleteRows_Bufferred)
#define THE_CLASS DeleteRows_Bufferred
BEG_TEST_CASE(DeleteRows_Bufferred, CExecutionManager, L"Test Notifications for IRowsetChange::DeleteRows in Buffered Mode")
TEST_VARIATION(1, L"ROW_DELETE - SINGLEROW - Accept all phases")
TEST_VARIATION(2, L"ROW_DELETE - MULTIPLEROWS - Accept all phases")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_DELETE - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_DELETE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_DELETE - Veto OKTODO Listener 1")
TEST_VARIATION(9, L"ROW_DELETE - Veto ABOUTTODO Listener 1")
TEST_VARIATION(10, L"ROW_DELETE - Veto SYNCHAFTER Listener 1")
TEST_VARIATION(11, L"ROW_DELETE - Veto DIDEVENT Listener 2")
TEST_VARIATION(12, L"ROW_DELETE - Veto FAILEDTODO Listener 2")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_DELETE - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_DELETE - UNWANTED PHASE OKTODO")
TEST_VARIATION(17, L"ROW_DELETE - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(18, L"ROW_DELETE - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(19, L"ROW_DELETE - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(20, L"ROW_DELETE - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_DELETE - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_DELETE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_DELETE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"OTHER SCENARIOS - Delete no rows")
TEST_VARIATION(29, L"OTHER SCENARIOS - DBROWSTATUS_DELETED")
TEST_VARIATION(30, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(31, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(32, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(33, L"OTHER SCENARIOS - GetOriginalData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(InsertRow)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetChange::InsertRow
//
class InsertRow : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(InsertRow,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_INSERT - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_INSERT - DB_E_NOTREENTRANT
int Variation_4();
// @cmember ROW_INSERT - DB_E_CANCELED
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_INSERT - Veto OKTODO, Listener 1
int Variation_8();
// @cmember ROW_INSERT - Veto ABOUTTODO, Listener 1
int Variation_9();
// @cmember ROW_INSERT - Veto SYNCHAFTER, Listener 2
int Variation_10();
// @cmember ROW_INSERT - Veto DIDEVENT, Listener 3
int Variation_11();
// @cmember ROW_INSERT - Veto FAILEDTODO, Listener 3
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember ROW_INSERT - UNWANTED REASON
int Variation_14();
// @cmember ROW_INSERT - UNWANTED PHASE OKTODO
int Variation_15();
// @cmember ROW_INSERT - UNWANTED PHASE ABOUTTODO
int Variation_16();
// @cmember ROW_INSERT - UNWANTED PHASE SYNCHAFTER
int Variation_17();
// @cmember ROW_INSERT - UNWANTED PHASE DIDEVENT
int Variation_18();
// @cmember ROW_INSERT - UNWANTED PHASE FAILEDTODO
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember ROW_INSERT - E_FAIL - All Phases
int Variation_22();
// @cmember ROW_INSERT - E_OUTOFMEMORY - All Phases
int Variation_23();
// @cmember ROW_INSERT - E_INVALIDARG - All Phases
int Variation_24();
// @cmember Empty
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
int Variation_27();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_28();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_29();
// @cmember OTHER SCENARIOS - GetData
int Variation_30();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(InsertRow)
#define THE_CLASS InsertRow
BEG_TEST_CASE(InsertRow, CExecutionManager, L"Tests Notifications for IRowsetChange::InsertRow")
TEST_VARIATION(1, L"ROW_INSERT - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_INSERT - DB_E_NOTREENTRANT")
TEST_VARIATION(5, L"ROW_INSERT - DB_E_CANCELED")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_INSERT - Veto OKTODO, Listener 1")
TEST_VARIATION(9, L"ROW_INSERT - Veto ABOUTTODO, Listener 1")
TEST_VARIATION(10, L"ROW_INSERT - Veto SYNCHAFTER, Listener 2")
TEST_VARIATION(11, L"ROW_INSERT - Veto DIDEVENT, Listener 3")
TEST_VARIATION(12, L"ROW_INSERT - Veto FAILEDTODO, Listener 3")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"ROW_INSERT - UNWANTED REASON")
TEST_VARIATION(15, L"ROW_INSERT - UNWANTED PHASE OKTODO")
TEST_VARIATION(16, L"ROW_INSERT - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(17, L"ROW_INSERT - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(18, L"ROW_INSERT - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(19, L"ROW_INSERT - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"ROW_INSERT - E_FAIL - All Phases")
TEST_VARIATION(23, L"ROW_INSERT - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(24, L"ROW_INSERT - E_INVALIDARG - All Phases")
TEST_VARIATION(25, L"Empty")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"OTHER SCENARIOS - DB_E_BADACCESSORHANDLE")
TEST_VARIATION(28, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(29, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(30, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(InsertRow_Bufferred)
//--------------------------------------------------------------------
// @class Test Notifications for IRowsetChange::InsertRow in Buffered Mode
//
class InsertRow_Bufferred : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(InsertRow_Bufferred,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_INSERT - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_INSERT - DB_E_NOTREENTRANT
int Variation_4();
// @cmember ROW_INSERT - DB_E_CANCELED
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_INSERT - Veto OKTODO, Listener 1
int Variation_8();
// @cmember ROW_INSERT - Veto ABOUTTODO, Listener 1
int Variation_9();
// @cmember ROW_INSERT - Veto SYNCHAFTER, Listener 2
int Variation_10();
// @cmember ROW_INSERT - Veto DIDEVENT, Listener 3
int Variation_11();
// @cmember ROW_INSERT - Veto FAILEDTODO, Listener 3
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember ROW_INSERT - UNWANTED REASON
int Variation_14();
// @cmember ROW_INSERT - UNWANTED PHASE OKTODO
int Variation_15();
// @cmember ROW_INSERT - UNWANTED PHASE ABOUTTODO
int Variation_16();
// @cmember ROW_INSERT - UNWANTED PHASE SYNCHAFTER
int Variation_17();
// @cmember ROW_INSERT - UNWANTED PHASE DIDEVENT
int Variation_18();
// @cmember ROW_INSERT - UNWANTED PHASE FAILEDTODO
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember ROW_INSERT - E_FAIL - All Phases
int Variation_22();
// @cmember ROW_INSERT - E_OUTOFMEMORY - All Phases
int Variation_23();
// @cmember ROW_INSERT - E_INVALIDARG - All Phases
int Variation_24();
// @cmember Empty
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
int Variation_27();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_28();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_29();
// @cmember OTHER SCENARIOS - GetData
int Variation_30();
// @cmember OTHER SCENARIOS - GetOriginalData
int Variation_31();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(InsertRow_Bufferred)
#define THE_CLASS InsertRow_Bufferred
BEG_TEST_CASE(InsertRow_Bufferred, CExecutionManager, L"Test Notifications for IRowsetChange::InsertRow in Buffered Mode")
TEST_VARIATION(1, L"ROW_INSERT - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_INSERT - DB_E_NOTREENTRANT")
TEST_VARIATION(5, L"ROW_INSERT - DB_E_CANCELED")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_INSERT - Veto OKTODO, Listener 1")
TEST_VARIATION(9, L"ROW_INSERT - Veto ABOUTTODO, Listener 1")
TEST_VARIATION(10, L"ROW_INSERT - Veto SYNCHAFTER, Listener 2")
TEST_VARIATION(11, L"ROW_INSERT - Veto DIDEVENT, Listener 3")
TEST_VARIATION(12, L"ROW_INSERT - Veto FAILEDTODO, Listener 3")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"ROW_INSERT - UNWANTED REASON")
TEST_VARIATION(15, L"ROW_INSERT - UNWANTED PHASE OKTODO")
TEST_VARIATION(16, L"ROW_INSERT - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(17, L"ROW_INSERT - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(18, L"ROW_INSERT - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(19, L"ROW_INSERT - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"ROW_INSERT - E_FAIL - All Phases")
TEST_VARIATION(23, L"ROW_INSERT - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(24, L"ROW_INSERT - E_INVALIDARG - All Phases")
TEST_VARIATION(25, L"Empty")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"OTHER SCENARIOS - DB_E_BADACCESSORHANDLE")
TEST_VARIATION(28, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(29, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(30, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(31, L"OTHER SCENARIOS - GetOriginalData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(SetData)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetChange::SetData
//
class SetData : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(SetData,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember COLUMN_SET - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember COLUMN_SET - DB_E_CANCELED
int Variation_4();
// @cmember COLUMN_SET - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember COLUMN_SET - Veto OKTODO
int Variation_8();
// @cmember COLUMN_SET - Veto ABOUTTODO
int Variation_9();
// @cmember COLUMN_SET - Veto SYNCHAFTER
int Variation_10();
// @cmember COLUMN_SET - Veto DIDEVENT
int Variation_11();
// @cmember COLUMN_SET - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember COLUMN_SET - UNWANTED REASON
int Variation_14();
// @cmember COLUMN_SET - UNWANTED PHASE OKTODO
int Variation_15();
// @cmember COLUMN_SET - UNWANTED PHASE ABOUTTO
int Variation_16();
// @cmember COLUMN_SET - UNWANTED PHASE SYNCHAFTER
int Variation_17();
// @cmember COLUMN_SET- UNWANTED PHASE DIDEVENT
int Variation_18();
// @cmember COLUMN_SET - UNWANTED PHASE FAILEDTODO
int Variation_19();
// @cmember Empty
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember COLUMN_SET - E_FAIL - All Phases
int Variation_22();
// @cmember COLUMN_SET - E_OUTOFMEMORY - All Phases
int Variation_23();
// @cmember COLUMN_SET - E_INVALIDARG - All Phases
int Variation_24();
// @cmember Empty
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember COLUMN_RECALCULATED - DB_E_ERRORSOCCURRED - Accept all phases
int Variation_27();
// @cmember Empty
int Variation_28();
// @cmember Empty
int Variation_29();
// @cmember COLUMN_RECALCULATED - DB_E_CANCELED
int Variation_30();
// @cmember COLUMN_RECALCULATED - DB_E_NOTREENTRANT
int Variation_31();
// @cmember Empty
int Variation_32();
// @cmember Empty
int Variation_33();
// @cmember COLUMN_RECALCULATED - Veto DIDEVENT
int Variation_34();
// @cmember Empty
int Variation_35();
// @cmember Empty
int Variation_36();
// @cmember COLUMN_RECALCULATED - UNWANTED REASON
int Variation_37();
// @cmember COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT
int Variation_38();
// @cmember Empty
int Variation_39();
// @cmember Empty
int Variation_40();
// @cmember COLUMN_RECALCULATED - E_FAIL - All Phases
int Variation_41();
// @cmember COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases
int Variation_42();
// @cmember COLUMN_RECALCULATED - E_INVALIDARG - All Phases
int Variation_43();
// @cmember Empty
int Variation_44();
// @cmember Empty
int Variation_45();
// @cmember OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
int Variation_46();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_47();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_48();
// @cmember OTHER SCENARIOS - GetData
int Variation_49();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(SetData)
#define THE_CLASS SetData
BEG_TEST_CASE(SetData, CExecutionManager, L"Tests Notifications for IRowsetChange::SetData")
TEST_VARIATION(1, L"COLUMN_SET - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"COLUMN_SET - DB_E_CANCELED")
TEST_VARIATION(5, L"COLUMN_SET - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"COLUMN_SET - Veto OKTODO")
TEST_VARIATION(9, L"COLUMN_SET - Veto ABOUTTODO")
TEST_VARIATION(10, L"COLUMN_SET - Veto SYNCHAFTER")
TEST_VARIATION(11, L"COLUMN_SET - Veto DIDEVENT")
TEST_VARIATION(12, L"COLUMN_SET - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"COLUMN_SET - UNWANTED REASON")
TEST_VARIATION(15, L"COLUMN_SET - UNWANTED PHASE OKTODO")
TEST_VARIATION(16, L"COLUMN_SET - UNWANTED PHASE ABOUTTO")
TEST_VARIATION(17, L"COLUMN_SET - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(18, L"COLUMN_SET- UNWANTED PHASE DIDEVENT")
TEST_VARIATION(19, L"COLUMN_SET - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(20, L"Empty")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"COLUMN_SET - E_FAIL - All Phases")
TEST_VARIATION(23, L"COLUMN_SET - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(24, L"COLUMN_SET - E_INVALIDARG - All Phases")
TEST_VARIATION(25, L"Empty")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"COLUMN_RECALCULATED - DB_E_ERRORSOCCURRED - Accept all phases")
TEST_VARIATION(28, L"Empty")
TEST_VARIATION(29, L"Empty")
TEST_VARIATION(30, L"COLUMN_RECALCULATED - DB_E_CANCELED")
TEST_VARIATION(31, L"COLUMN_RECALCULATED - DB_E_NOTREENTRANT")
TEST_VARIATION(32, L"Empty")
TEST_VARIATION(33, L"Empty")
TEST_VARIATION(34, L"COLUMN_RECALCULATED - Veto DIDEVENT")
TEST_VARIATION(35, L"Empty")
TEST_VARIATION(36, L"Empty")
TEST_VARIATION(37, L"COLUMN_RECALCULATED - UNWANTED REASON")
TEST_VARIATION(38, L"COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(39, L"Empty")
TEST_VARIATION(40, L"Empty")
TEST_VARIATION(41, L"COLUMN_RECALCULATED - E_FAIL - All Phases")
TEST_VARIATION(42, L"COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(43, L"COLUMN_RECALCULATED - E_INVALIDARG - All Phases")
TEST_VARIATION(44, L"Empty")
TEST_VARIATION(45, L"Empty")
TEST_VARIATION(46, L"OTHER SCENARIOS - DB_E_BADACCESSORHANDLE")
TEST_VARIATION(47, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(48, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(49, L"OTHER SCENARIOS - GetData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(SetData_Bufferred)
//--------------------------------------------------------------------
// @class Test Notifications for IRowsetChange::SetData in Buffered Mode
//
class SetData_Bufferred : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(SetData_Bufferred,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_FIRSTCHANGE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_FIRSTCHANGE - DB_E_CANCELED
int Variation_4();
// @cmember ROW_FIRSTCHANGE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_FIRSTCHANGE - Veto OKTODO
int Variation_8();
// @cmember ROW_FIRSTCHANGE - Veto ABOUTTODO
int Variation_9();
// @cmember ROW_FIRSTCHANGE - Veto SYNCHAFTER
int Variation_10();
// @cmember ROW_FIRSTCHANGE - Veto DIDEVENT
int Variation_11();
// @cmember ROW_FIRSTCHANGE - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_FIRSTCHANGE - UNWANTED REASON
int Variation_15();
// @cmember ROW_FIRSTCHANGE - UNWANTED PHASE OKTODO
int Variation_16();
// @cmember ROW_FIRSTCHANGE - UNWANTED PHASE ABOUTTODO
int Variation_17();
// @cmember ROW_FIRSTCHANGE - UNWANTED PHASE SYNCHAFTER
int Variation_18();
// @cmember ROW_FIRSTCHANGE - UNWANTED PHASE DIDEVENT
int Variation_19();
// @cmember ROW_FIRSTCHANGE - UNWANTED PHASE FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_FIRSTCHANGE - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_FIRSTCHANGE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_FIRSTCHANGE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember COLUMN_SET - Accept all phases
int Variation_28();
// @cmember Empty
int Variation_29();
// @cmember Empty
int Variation_30();
// @cmember COLUMN_SET - DB_E_CANCELED
int Variation_31();
// @cmember COLUMN_SET - DB_E_NOTREENTRANT
int Variation_32();
// @cmember Empty
int Variation_33();
// @cmember Empty
int Variation_34();
// @cmember COLUMN_SET - Veto OKTODO
int Variation_35();
// @cmember COLUMN_SET - Veto ABOUTTODO
int Variation_36();
// @cmember COLUMN_SET - Veto SYNCHAFTER
int Variation_37();
// @cmember COLUMN_SET - Veto DIDEVENT
int Variation_38();
// @cmember COLUMN_SET - Veto FAILEDTODO
int Variation_39();
// @cmember Empty
int Variation_40();
// @cmember COLUMN_SET - UNWANTED REASON
int Variation_41();
// @cmember COLUMN_SET - UNWANTED PHASE OKTODO
int Variation_42();
// @cmember COLUMN_SET - UNWANTED PHASE ABOUTTO
int Variation_43();
// @cmember COLUMN_SET - UNWANTED PHASE SYNCHAFTER
int Variation_44();
// @cmember COLUMN_SET- UNWANTED PHASE DIDEVENT
int Variation_45();
// @cmember COLUMN_SET - UNWANTED PHASE FAILEDTODO
int Variation_46();
// @cmember Empty
int Variation_47();
// @cmember Empty
int Variation_48();
// @cmember COLUMN_SET - E_FAIL - All Phases
int Variation_49();
// @cmember COLUMN_SET - E_OUTOFMEMORY - All Phases
int Variation_50();
// @cmember COLUMN_SET - E_INVALIDARG - All Phases
int Variation_51();
// @cmember Empty
int Variation_52();
// @cmember Empty
int Variation_53();
// @cmember COLUMN_RECALCULATED - Accept all phases
int Variation_54();
// @cmember Empty
int Variation_55();
// @cmember Empty
int Variation_56();
// @cmember COLUMN_RECALCULATED - DB_E_CANCELED
int Variation_57();
// @cmember COLUMN_RECALCULATED - DB_E_NOTREENTRANT
int Variation_58();
// @cmember Empty
int Variation_59();
// @cmember Empty
int Variation_60();
// @cmember COLUMN_RECALCULATED - Veto DIDEVENT
int Variation_61();
// @cmember Empty
int Variation_62();
// @cmember Empty
int Variation_63();
// @cmember COLUMN_RECALCULATED - UNWANTED REASON
int Variation_64();
// @cmember COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT
int Variation_65();
// @cmember Empty
int Variation_66();
// @cmember Empty
int Variation_67();
// @cmember COLUMN_RECALCULATED - E_FAIL - All Phases
int Variation_68();
// @cmember COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases
int Variation_69();
// @cmember COLUMN_RECALCULATED - E_INVALIDARG - All Phases
int Variation_70();
// @cmember Empty
int Variation_71();
// @cmember Empty
int Variation_72();
// @cmember OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
int Variation_73();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_74();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_75();
// @cmember OTHER SCENARIOS - GetData
int Variation_76();
// @cmember OTHER SCENARIOS - GetOriginalData
int Variation_77();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(SetData_Bufferred)
#define THE_CLASS SetData_Bufferred
BEG_TEST_CASE(SetData_Bufferred, CExecutionManager, L"Test Notifications for IRowsetChange::SetData in Buffered Mode")
TEST_VARIATION(1, L"ROW_FIRSTCHANGE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_FIRSTCHANGE - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_FIRSTCHANGE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_FIRSTCHANGE - Veto OKTODO")
TEST_VARIATION(9, L"ROW_FIRSTCHANGE - Veto ABOUTTODO")
TEST_VARIATION(10, L"ROW_FIRSTCHANGE - Veto SYNCHAFTER")
TEST_VARIATION(11, L"ROW_FIRSTCHANGE - Veto DIDEVENT")
TEST_VARIATION(12, L"ROW_FIRSTCHANGE - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_FIRSTCHANGE - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_FIRSTCHANGE - UNWANTED PHASE OKTODO")
TEST_VARIATION(17, L"ROW_FIRSTCHANGE - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(18, L"ROW_FIRSTCHANGE - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(19, L"ROW_FIRSTCHANGE - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(20, L"ROW_FIRSTCHANGE - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_FIRSTCHANGE - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_FIRSTCHANGE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_FIRSTCHANGE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"COLUMN_SET - Accept all phases")
TEST_VARIATION(29, L"Empty")
TEST_VARIATION(30, L"Empty")
TEST_VARIATION(31, L"COLUMN_SET - DB_E_CANCELED")
TEST_VARIATION(32, L"COLUMN_SET - DB_E_NOTREENTRANT")
TEST_VARIATION(33, L"Empty")
TEST_VARIATION(34, L"Empty")
TEST_VARIATION(35, L"COLUMN_SET - Veto OKTODO")
TEST_VARIATION(36, L"COLUMN_SET - Veto ABOUTTODO")
TEST_VARIATION(37, L"COLUMN_SET - Veto SYNCHAFTER")
TEST_VARIATION(38, L"COLUMN_SET - Veto DIDEVENT")
TEST_VARIATION(39, L"COLUMN_SET - Veto FAILEDTODO")
TEST_VARIATION(40, L"Empty")
TEST_VARIATION(41, L"COLUMN_SET - UNWANTED REASON")
TEST_VARIATION(42, L"COLUMN_SET - UNWANTED PHASE OKTODO")
TEST_VARIATION(43, L"COLUMN_SET - UNWANTED PHASE ABOUTTO")
TEST_VARIATION(44, L"COLUMN_SET - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(45, L"COLUMN_SET- UNWANTED PHASE DIDEVENT")
TEST_VARIATION(46, L"COLUMN_SET - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(47, L"Empty")
TEST_VARIATION(48, L"Empty")
TEST_VARIATION(49, L"COLUMN_SET - E_FAIL - All Phases")
TEST_VARIATION(50, L"COLUMN_SET - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(51, L"COLUMN_SET - E_INVALIDARG - All Phases")
TEST_VARIATION(52, L"Empty")
TEST_VARIATION(53, L"Empty")
TEST_VARIATION(54, L"COLUMN_RECALCULATED - Accept all phases")
TEST_VARIATION(55, L"Empty")
TEST_VARIATION(56, L"Empty")
TEST_VARIATION(57, L"COLUMN_RECALCULATED - DB_E_CANCELED")
TEST_VARIATION(58, L"COLUMN_RECALCULATED - DB_E_NOTREENTRANT")
TEST_VARIATION(59, L"Empty")
TEST_VARIATION(60, L"Empty")
TEST_VARIATION(61, L"COLUMN_RECALCULATED - Veto DIDEVENT")
TEST_VARIATION(62, L"Empty")
TEST_VARIATION(63, L"Empty")
TEST_VARIATION(64, L"COLUMN_RECALCULATED - UNWANTED REASON")
TEST_VARIATION(65, L"COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(66, L"Empty")
TEST_VARIATION(67, L"Empty")
TEST_VARIATION(68, L"COLUMN_RECALCULATED - E_FAIL - All Phases")
TEST_VARIATION(69, L"COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(70, L"COLUMN_RECALCULATED - E_INVALIDARG - All Phases")
TEST_VARIATION(71, L"Empty")
TEST_VARIATION(72, L"Empty")
TEST_VARIATION(73, L"OTHER SCENARIOS - DB_E_BADACCESSORHANDLE")
TEST_VARIATION(74, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(75, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(76, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(77, L"OTHER SCENARIOS - GetOriginalData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Resynch)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetResynch::ResyncRows
//
class Resynch : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Resynch,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_RESYNCH - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_RESYNCH - DB_E_CANCELED
int Variation_4();
// @cmember ROW_RESYNCH - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_RESYNCH - Veto OKTODO
int Variation_8();
// @cmember ROW_RESYNCH - Veto ABOUTTODO
int Variation_9();
// @cmember ROW_RESYNCH - Veto SYNCHAFTER
int Variation_10();
// @cmember ROW_RESYNCH - Veto DIDEVENT
int Variation_11();
// @cmember ROW_RESYNCH - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_RESYNCH - UNWANTED REASON
int Variation_15();
// @cmember ROW_RESYNCH - UNWANTED PHASE - OKTODO
int Variation_16();
// @cmember ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO
int Variation_17();
// @cmember ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER
int Variation_18();
// @cmember ROW_RESYNCH - UNWANTED PHASE - DIDEVENT
int Variation_19();
// @cmember ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_RESYNCH - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_RESYNCH - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_RESYNCH - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember OTHER SCENARIOS - Resynch all rows
int Variation_28();
// @cmember OTHER SCENARIOS - Resynch 2 rows, 1 changed 1 not changed
int Variation_29();
// @cmember OTHER SCENARIOS - 1 valid, 1 not valid
int Variation_30();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_31();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_32();
// @cmember OTHER SCENARIOS - GetData
int Variation_33();
// @cmember OTHER SCENARIOS - GetVisibleData
int Variation_34();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Resynch)
#define THE_CLASS Resynch
BEG_TEST_CASE(Resynch, CExecutionManager, L"Tests Notifications for IRowsetResynch::ResyncRows")
TEST_VARIATION(1, L"ROW_RESYNCH - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_RESYNCH - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_RESYNCH - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_RESYNCH - Veto OKTODO")
TEST_VARIATION(9, L"ROW_RESYNCH - Veto ABOUTTODO")
TEST_VARIATION(10, L"ROW_RESYNCH - Veto SYNCHAFTER")
TEST_VARIATION(11, L"ROW_RESYNCH - Veto DIDEVENT")
TEST_VARIATION(12, L"ROW_RESYNCH - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_RESYNCH - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_RESYNCH - UNWANTED PHASE - OKTODO")
TEST_VARIATION(17, L"ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(18, L"ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(19, L"ROW_RESYNCH - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(20, L"ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_RESYNCH - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_RESYNCH - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_RESYNCH - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"OTHER SCENARIOS - Resynch all rows")
TEST_VARIATION(29, L"OTHER SCENARIOS - Resynch 2 rows, 1 changed 1 not changed")
TEST_VARIATION(30, L"OTHER SCENARIOS - 1 valid, 1 not valid")
TEST_VARIATION(31, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(32, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(33, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(34, L"OTHER SCENARIOS - GetVisibleData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Resynch_Bufferred)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetResynch_Bufferred::ResyncRows
//
class Resynch_Bufferred : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Resynch_Bufferred,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_RESYNCH - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_RESYNCH - DB_E_CANCELED
int Variation_4();
// @cmember ROW_RESYNCH - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_RESYNCH - Veto OKTODO
int Variation_8();
// @cmember ROW_RESYNCH - Veto ABOUTTODO
int Variation_9();
// @cmember ROW_RESYNCH - Veto SYNCHAFTER
int Variation_10();
// @cmember ROW_RESYNCH - Veto DIDEVENT
int Variation_11();
// @cmember ROW_RESYNCH - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_RESYNCH - UNWANTED REASON
int Variation_15();
// @cmember ROW_RESYNCH - UNWANTED PHASE - OKTODO
int Variation_16();
// @cmember ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO
int Variation_17();
// @cmember ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER
int Variation_18();
// @cmember ROW_RESYNCH - UNWANTED PHASE - DIDEVENT
int Variation_19();
// @cmember ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_RESYNCH - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_RESYNCH - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_RESYNCH - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember OTHER SCENARIOS - Resynch_Bufferred all rows
int Variation_28();
// @cmember OTHER SCENARIOS - Resynch_Bufferred 2 rows, 1 changed 1 not changed
int Variation_29();
// @cmember OTHER SCENARIOS - 1 valid, 1 not valid
int Variation_30();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_31();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_32();
// @cmember OTHER SCENARIOS - GetData
int Variation_33();
// @cmember OTHER SCENARIOS - GetVisibleData
int Variation_34();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Resynch_Bufferred)
#define THE_CLASS Resynch_Bufferred
BEG_TEST_CASE(Resynch_Bufferred, CExecutionManager, L"Tests Notifications for IRowsetResynch_Bufferred::ResyncRows")
TEST_VARIATION(1, L"ROW_RESYNCH - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_RESYNCH - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_RESYNCH - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_RESYNCH - Veto OKTODO")
TEST_VARIATION(9, L"ROW_RESYNCH - Veto ABOUTTODO")
TEST_VARIATION(10, L"ROW_RESYNCH - Veto SYNCHAFTER")
TEST_VARIATION(11, L"ROW_RESYNCH - Veto DIDEVENT")
TEST_VARIATION(12, L"ROW_RESYNCH - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_RESYNCH - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_RESYNCH - UNWANTED PHASE - OKTODO")
TEST_VARIATION(17, L"ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(18, L"ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(19, L"ROW_RESYNCH - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(20, L"ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_RESYNCH - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_RESYNCH - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_RESYNCH - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"OTHER SCENARIOS - Resynch_Bufferred all rows")
TEST_VARIATION(29, L"OTHER SCENARIOS - Resynch_Bufferred 2 rows, 1 changed 1 not changed")
TEST_VARIATION(30, L"OTHER SCENARIOS - 1 valid, 1 not valid")
TEST_VARIATION(31, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(32, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(33, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(34, L"OTHER SCENARIOS - GetVisibleData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Undo)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetUpdate::Undo
//
class Undo : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Undo,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_UNDOCHANGE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_UNDOCHANGE - DB_E_CANCELED
int Variation_4();
// @cmember ROW_UNDOCHANGE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_UNDOCHANGE - Veto OKTODO
int Variation_8();
// @cmember ROW_UNDOCHANGE - Veto ABOUTTODO
int Variation_9();
// @cmember ROW_UNDOCHANGE - Veto SYNCHAFTER
int Variation_10();
// @cmember ROW_UNDOCHANGE - Veto DIDEVENT
int Variation_11();
// @cmember ROW_UNDOCHANGE - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_UNDOCHANGE - UNWANTED REASON
int Variation_15();
// @cmember ROW_UNDOCHANGE - UNWANTED PHASE OKTODO
int Variation_16();
// @cmember ROW_UNDOCHANGE - UNWANTED PHASE ABOUTTODO
int Variation_17();
// @cmember ROW_UNDOCHANGE - UNWANTED PHASE SYNCHAFTER
int Variation_18();
// @cmember ROW_UNDOCHANGE - UNWANTED PHASE DIDEVENT
int Variation_19();
// @cmember ROW_UNDOCHANGE - UNWANTED PHASE FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_UNDOCHANGE - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_UNDOCHANGE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_UNDOCHANGE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember ROW_UNDOINSERT - Accept all phases
int Variation_28();
// @cmember Empty
int Variation_29();
// @cmember Empty
int Variation_30();
// @cmember ROW_UNDOINSERT - DB_E_CANCELED
int Variation_31();
// @cmember ROW_UNDOINSERT - DB_E_NOTREENTRANT
int Variation_32();
// @cmember Empty
int Variation_33();
// @cmember Empty
int Variation_34();
// @cmember ROW_UNDOINSERT - Veto OKTODO
int Variation_35();
// @cmember ROW_UNDOINSERT - Veto ABOUTTODO
int Variation_36();
// @cmember ROW_UNDOINSERT - Veto SYNCHAFTER
int Variation_37();
// @cmember ROW_UNDOINSERT - Veto DIDEVENT
int Variation_38();
// @cmember ROW_UNDOINSERT - Veto FAILEDTODO
int Variation_39();
// @cmember Empty
int Variation_40();
// @cmember ROW_UNDOINSERT - UNWANTED REASON
int Variation_41();
// @cmember ROW_UNDOINSERT - UNWANTED PHASE OKTODO
int Variation_42();
// @cmember ROW_UNDOINSERT - UNWANTED PHASE ABOUTTO
int Variation_43();
// @cmember ROW_UNDOINSERT - UNWANTED PHASE SYNCHAFTER
int Variation_44();
// @cmember ROW_UNDOINSERT- UNWANTED PHASE DIDEVENT
int Variation_45();
// @cmember ROW_UNDOINSERT - UNWANTED PHASE FAILEDTODO
int Variation_46();
// @cmember Empty
int Variation_47();
// @cmember Empty
int Variation_48();
// @cmember ROW_UNDOINSERT - E_FAIL - All Phases
int Variation_49();
// @cmember ROW_UNDOINSERT - E_OUTOFMEMORY - All Phases
int Variation_50();
// @cmember ROW_UNDOINSERT - E_INVALIDARG - All Phases
int Variation_51();
// @cmember Empty
int Variation_52();
// @cmember Empty
int Variation_53();
// @cmember ROW_UNDODELETE - Accept all phases
int Variation_54();
// @cmember Empty
int Variation_55();
// @cmember Empty
int Variation_56();
// @cmember ROW_UNDODELETE - DB_E_CANCELED
int Variation_57();
// @cmember ROW_UNDODELETE - DB_E_NOTREENTRANT
int Variation_58();
// @cmember Empty
int Variation_59();
// @cmember Empty
int Variation_60();
// @cmember ROW_UNDODELETE - Veto OKTODO
int Variation_61();
// @cmember ROW_UNDODELETE - Veto ABOUTTODO
int Variation_62();
// @cmember ROW_UNDODELETE - Veto SYNCHAFTER
int Variation_63();
// @cmember ROW_UNDODELETE - Veto DIDEVENT
int Variation_64();
// @cmember ROW_UNDODELETE - Veto FAILEDTODO
int Variation_65();
// @cmember Empty
int Variation_66();
// @cmember Empty
int Variation_67();
// @cmember ROW_UNDODELETE - UNWANTED REASON
int Variation_68();
// @cmember ROW_UNDODELETE - UNWANTED PHASE OKTODO
int Variation_69();
// @cmember ROW_UNDODELETE - UNWANTED PHASE ABOUTTODO
int Variation_70();
// @cmember ROW_UNDODELETE - UNWANTED PHASE SYNCHAFTER
int Variation_71();
// @cmember ROW_UNDODELETE - UNWANTED PHASE DIDEVENT
int Variation_72();
// @cmember ROW_UNDODELETE - UNWANTED PHASE FAILEDTODO
int Variation_73();
// @cmember Empty
int Variation_74();
// @cmember Empty
int Variation_75();
// @cmember ROW_UNDODELETE - E_FAIL - All Phases
int Variation_76();
// @cmember ROW_UNDODELETE - E_OUTOFMEMORY - All Phases
int Variation_77();
// @cmember ROW_UNDODELETE - E_INVALIDARG - All Phases
int Variation_78();
// @cmember Empty
int Variation_79();
// @cmember Empty
int Variation_80();
// @cmember OTHER SCENARIOS - Undo unchanged row
int Variation_81();
// @cmember OTHER SCENARIOS - Undo all rows
int Variation_82();
// @cmember OTHER SCENARIOS - Undo changed and unchanged
int Variation_83();
// @cmember Empty
int Variation_84();
// @cmember OTHER SCENARIOS - Verify Undo clears the FIRSTCHANGE status
int Variation_85();
// @cmember Empty
int Variation_86();
// @cmember OTHER SCENARIOS - DBROWSTATUS_E_INVALID
int Variation_87();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_88();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_89();
// @cmember OTHER SCENARIOS - GetData
int Variation_90();
// @cmember OTHER SCENARIOS - GetOriginalData
int Variation_91();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Undo)
#define THE_CLASS Undo
BEG_TEST_CASE(Undo, CExecutionManager, L"Tests Notifications for IRowsetUpdate::Undo")
TEST_VARIATION(1, L"ROW_UNDOCHANGE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_UNDOCHANGE - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_UNDOCHANGE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_UNDOCHANGE - Veto OKTODO")
TEST_VARIATION(9, L"ROW_UNDOCHANGE - Veto ABOUTTODO")
TEST_VARIATION(10, L"ROW_UNDOCHANGE - Veto SYNCHAFTER")
TEST_VARIATION(11, L"ROW_UNDOCHANGE - Veto DIDEVENT")
TEST_VARIATION(12, L"ROW_UNDOCHANGE - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_UNDOCHANGE - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_UNDOCHANGE - UNWANTED PHASE OKTODO")
TEST_VARIATION(17, L"ROW_UNDOCHANGE - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(18, L"ROW_UNDOCHANGE - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(19, L"ROW_UNDOCHANGE - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(20, L"ROW_UNDOCHANGE - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_UNDOCHANGE - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_UNDOCHANGE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_UNDOCHANGE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"ROW_UNDOINSERT - Accept all phases")
TEST_VARIATION(29, L"Empty")
TEST_VARIATION(30, L"Empty")
TEST_VARIATION(31, L"ROW_UNDOINSERT - DB_E_CANCELED")
TEST_VARIATION(32, L"ROW_UNDOINSERT - DB_E_NOTREENTRANT")
TEST_VARIATION(33, L"Empty")
TEST_VARIATION(34, L"Empty")
TEST_VARIATION(35, L"ROW_UNDOINSERT - Veto OKTODO")
TEST_VARIATION(36, L"ROW_UNDOINSERT - Veto ABOUTTODO")
TEST_VARIATION(37, L"ROW_UNDOINSERT - Veto SYNCHAFTER")
TEST_VARIATION(38, L"ROW_UNDOINSERT - Veto DIDEVENT")
TEST_VARIATION(39, L"ROW_UNDOINSERT - Veto FAILEDTODO")
TEST_VARIATION(40, L"Empty")
TEST_VARIATION(41, L"ROW_UNDOINSERT - UNWANTED REASON")
TEST_VARIATION(42, L"ROW_UNDOINSERT - UNWANTED PHASE OKTODO")
TEST_VARIATION(43, L"ROW_UNDOINSERT - UNWANTED PHASE ABOUTTO")
TEST_VARIATION(44, L"ROW_UNDOINSERT - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(45, L"ROW_UNDOINSERT- UNWANTED PHASE DIDEVENT")
TEST_VARIATION(46, L"ROW_UNDOINSERT - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(47, L"Empty")
TEST_VARIATION(48, L"Empty")
TEST_VARIATION(49, L"ROW_UNDOINSERT - E_FAIL - All Phases")
TEST_VARIATION(50, L"ROW_UNDOINSERT - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(51, L"ROW_UNDOINSERT - E_INVALIDARG - All Phases")
TEST_VARIATION(52, L"Empty")
TEST_VARIATION(53, L"Empty")
TEST_VARIATION(54, L"ROW_UNDODELETE - Accept all phases")
TEST_VARIATION(55, L"Empty")
TEST_VARIATION(56, L"Empty")
TEST_VARIATION(57, L"ROW_UNDODELETE - DB_E_CANCELED")
TEST_VARIATION(58, L"ROW_UNDODELETE - DB_E_NOTREENTRANT")
TEST_VARIATION(59, L"Empty")
TEST_VARIATION(60, L"Empty")
TEST_VARIATION(61, L"ROW_UNDODELETE - Veto OKTODO")
TEST_VARIATION(62, L"ROW_UNDODELETE - Veto ABOUTTODO")
TEST_VARIATION(63, L"ROW_UNDODELETE - Veto SYNCHAFTER")
TEST_VARIATION(64, L"ROW_UNDODELETE - Veto DIDEVENT")
TEST_VARIATION(65, L"ROW_UNDODELETE - Veto FAILEDTODO")
TEST_VARIATION(66, L"Empty")
TEST_VARIATION(67, L"Empty")
TEST_VARIATION(68, L"ROW_UNDODELETE - UNWANTED REASON")
TEST_VARIATION(69, L"ROW_UNDODELETE - UNWANTED PHASE OKTODO")
TEST_VARIATION(70, L"ROW_UNDODELETE - UNWANTED PHASE ABOUTTODO")
TEST_VARIATION(71, L"ROW_UNDODELETE - UNWANTED PHASE SYNCHAFTER")
TEST_VARIATION(72, L"ROW_UNDODELETE - UNWANTED PHASE DIDEVENT")
TEST_VARIATION(73, L"ROW_UNDODELETE - UNWANTED PHASE FAILEDTODO")
TEST_VARIATION(74, L"Empty")
TEST_VARIATION(75, L"Empty")
TEST_VARIATION(76, L"ROW_UNDODELETE - E_FAIL - All Phases")
TEST_VARIATION(77, L"ROW_UNDODELETE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(78, L"ROW_UNDODELETE - E_INVALIDARG - All Phases")
TEST_VARIATION(79, L"Empty")
TEST_VARIATION(80, L"Empty")
TEST_VARIATION(81, L"OTHER SCENARIOS - Undo unchanged row")
TEST_VARIATION(82, L"OTHER SCENARIOS - Undo all rows")
TEST_VARIATION(83, L"OTHER SCENARIOS - Undo changed and unchanged")
TEST_VARIATION(84, L"Empty")
TEST_VARIATION(85, L"OTHER SCENARIOS - Verify Undo clears the FIRSTCHANGE status")
TEST_VARIATION(86, L"Empty")
TEST_VARIATION(87, L"OTHER SCENARIOS - DBROWSTATUS_E_INVALID")
TEST_VARIATION(88, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(89, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(90, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(91, L"OTHER SCENARIOS - GetOriginalData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Update)
//--------------------------------------------------------------------
// @class Tests Notifications for IRowsetUpdate::Update
//
class Update : public CExecutionManager {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Update,CExecutionManager);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember ROW_UPDATE - Accept all phases
int Variation_1();
// @cmember Empty
int Variation_2();
// @cmember Empty
int Variation_3();
// @cmember ROW_UPDATE - DB_E_CANCELED
int Variation_4();
// @cmember ROW_UPDATE - DB_E_NOTREENTRANT
int Variation_5();
// @cmember Empty
int Variation_6();
// @cmember Empty
int Variation_7();
// @cmember ROW_UPDATE - Veto OKTODO
int Variation_8();
// @cmember ROW_UPDATE - Veto ABOUTTODO
int Variation_9();
// @cmember ROW_UPDATE - Veto SYNCHAFTER
int Variation_10();
// @cmember ROW_UPDATE - Veto DIDEVENT
int Variation_11();
// @cmember ROW_UPDATE - Veto FAILEDTODO
int Variation_12();
// @cmember Empty
int Variation_13();
// @cmember Empty
int Variation_14();
// @cmember ROW_UPDATE - UNWANTED REASON
int Variation_15();
// @cmember ROW_UPDATE - UNWANTED PHASE - OKTODO
int Variation_16();
// @cmember ROW_UPDATE - UNWANTED PHASE - ABOUTTODO
int Variation_17();
// @cmember ROW_UPDATE - UNWANTED PHASE - SYNCHAFTER
int Variation_18();
// @cmember ROW_UPDATE - UNWANTED PHASE - DIDEVENT
int Variation_19();
// @cmember ROW_UPDATE - UNWANTED PHASE - FAILEDTODO
int Variation_20();
// @cmember Empty
int Variation_21();
// @cmember Empty
int Variation_22();
// @cmember ROW_UPDATE - E_FAIL - All Phases
int Variation_23();
// @cmember ROW_UPDATE - E_OUTOFMEMORY - All Phases
int Variation_24();
// @cmember ROW_UPDATE - E_INVALIDARG - All Phases
int Variation_25();
// @cmember Empty
int Variation_26();
// @cmember Empty
int Variation_27();
// @cmember OTHER SCENARIOS - Update all [no changes]
int Variation_28();
// @cmember OTHER SCENARIOS - Update all [changes]
int Variation_29();
// @cmember OTHER SCENARIOS - Update changed and unchanged
int Variation_30();
// @cmember Empty
int Variation_31();
// @cmember OTHER SCENARIOS - Verify Update clears FIRSTCHANGE status
int Variation_32();
// @cmember Empty
int Variation_33();
// @cmember OTHER SCENARIOS - DBROWSTATUS_E_INVALID
int Variation_34();
// @cmember OTHER SCENARIOS - EmptyRowset
int Variation_35();
// @cmember OTHER SCENARIOS - Add/Remove Listeners
int Variation_36();
// @cmember OTHER SCENARIOS - GetData
int Variation_37();
// @cmember OTHER SCENARIOS - GetOriginalData
int Variation_38();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Update)
#define THE_CLASS Update
BEG_TEST_CASE(Update, CExecutionManager, L"Tests Notifications for IRowsetUpdate::Update")
TEST_VARIATION(1, L"ROW_UPDATE - Accept all phases")
TEST_VARIATION(2, L"Empty")
TEST_VARIATION(3, L"Empty")
TEST_VARIATION(4, L"ROW_UPDATE - DB_E_CANCELED")
TEST_VARIATION(5, L"ROW_UPDATE - DB_E_NOTREENTRANT")
TEST_VARIATION(6, L"Empty")
TEST_VARIATION(7, L"Empty")
TEST_VARIATION(8, L"ROW_UPDATE - Veto OKTODO")
TEST_VARIATION(9, L"ROW_UPDATE - Veto ABOUTTODO")
TEST_VARIATION(10, L"ROW_UPDATE - Veto SYNCHAFTER")
TEST_VARIATION(11, L"ROW_UPDATE - Veto DIDEVENT")
TEST_VARIATION(12, L"ROW_UPDATE - Veto FAILEDTODO")
TEST_VARIATION(13, L"Empty")
TEST_VARIATION(14, L"Empty")
TEST_VARIATION(15, L"ROW_UPDATE - UNWANTED REASON")
TEST_VARIATION(16, L"ROW_UPDATE - UNWANTED PHASE - OKTODO")
TEST_VARIATION(17, L"ROW_UPDATE - UNWANTED PHASE - ABOUTTODO")
TEST_VARIATION(18, L"ROW_UPDATE - UNWANTED PHASE - SYNCHAFTER")
TEST_VARIATION(19, L"ROW_UPDATE - UNWANTED PHASE - DIDEVENT")
TEST_VARIATION(20, L"ROW_UPDATE - UNWANTED PHASE - FAILEDTODO")
TEST_VARIATION(21, L"Empty")
TEST_VARIATION(22, L"Empty")
TEST_VARIATION(23, L"ROW_UPDATE - E_FAIL - All Phases")
TEST_VARIATION(24, L"ROW_UPDATE - E_OUTOFMEMORY - All Phases")
TEST_VARIATION(25, L"ROW_UPDATE - E_INVALIDARG - All Phases")
TEST_VARIATION(26, L"Empty")
TEST_VARIATION(27, L"Empty")
TEST_VARIATION(28, L"OTHER SCENARIOS - Update all [no changes]")
TEST_VARIATION(29, L"OTHER SCENARIOS - Update all [changes]")
TEST_VARIATION(30, L"OTHER SCENARIOS - Update changed and unchanged")
TEST_VARIATION(31, L"Empty")
TEST_VARIATION(32, L"OTHER SCENARIOS - Verify Update clears FIRSTCHANGE status")
TEST_VARIATION(33, L"Empty")
TEST_VARIATION(34, L"OTHER SCENARIOS - DBROWSTATUS_E_INVALID")
TEST_VARIATION(35, L"OTHER SCENARIOS - EmptyRowset")
TEST_VARIATION(36, L"OTHER SCENARIOS - Add/Remove Listeners")
TEST_VARIATION(37, L"OTHER SCENARIOS - GetData")
TEST_VARIATION(38, L"OTHER SCENARIOS - GetOriginalData")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(18, ThisModule, gwszModuleDescrip)
TEST_CASE(1, Release)
TEST_CASE(2, GetNextRows)
TEST_CASE(3, ReleaseRows)
TEST_CASE(4, RestartPosition)
TEST_CASE(5, Seek)
TEST_CASE(6, GetRowsAt)
TEST_CASE(7, GetRowsByBookmark)
TEST_CASE(8, GetRowsAtRatio)
TEST_CASE(9, DeleteRows)
TEST_CASE(10, DeleteRows_Bufferred)
TEST_CASE(11, InsertRow)
TEST_CASE(12, InsertRow_Bufferred)
TEST_CASE(13, SetData)
TEST_CASE(14, SetData_Bufferred)
TEST_CASE(15, Resynch)
TEST_CASE(16, Resynch_Bufferred)
TEST_CASE(17, Undo)
TEST_CASE(18, Update)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
// {{ TCW_TC_PROTOTYPE(Release)
//*-----------------------------------------------------------------------
//| Test Case: Release - Tests Notifications for IRowset::Release
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Release::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
if(CreateRowset(DEFAULT_ROWSET)==S_OK)
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::Release() {} }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_4()
{
//Cannot "successfully" Veto DIDEVENT, so there is no use trying to
//use the rowset after Release() since it will no longer be valid
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_5()
{
//This really isn't a good senario to be testing DB_E_NOTREENTRANT
//Once the rowset sends DIDEVENT for IRowset::Release() its fairly dangerous
//to do anything!!
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_ACCEPT } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_8()
{
//Cannot "successfully" Veto DIDEVENT, so there is no use trying to
//use the rowset after Release() since it will no longer be valid
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_9()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_10()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_UNWANTEDREASON } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_UNWANTEDPHASE } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_EFAIL } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_EOUTOFMEMORY } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_RELEASE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_EINVALIDARG } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_18()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_19()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - AddRef - Release - no notifications
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::AddRef() {} "
L" IRowset::Release() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {L1.ROWSET_RELEASE.DIDEVENT.RETURN_ACCEPT } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {"
// L" L1.ROWSET_RELEASE.DIDEVENT.RETURN_UNADVISE "
// L" L2.ROWSET_RELEASE.DIDEVENT.RETURN_UNADVISE "
L" }"
L" }"
L" }"
L"}";
//NOTE: On ROWSET_RELEASE notification the rowset pointer is already released.
//So trying to QI for IConnectionPointContainer to advise/unadvise listeners may crash
//and is considered a user programming error...
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Release::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::Release() "
L" {"
// L" L1.ROWSET_RELEASE.DIDEVENT.RETURN_ADVISE "
// L" L2.ROWSET_RELEASE.DIDEVENT.RETURN_ADVISE "
L" }"
L" }"
L" }"
L"}";
//NOTE: On ROWSET_RELEASE notification the rowset pointer is already released.
//So trying to QI for IConnectionPointContainer to advise/unadvise listeners may crash
//and is considered a user programming error...
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Release::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetNextRows)
//*-----------------------------------------------------------------------
//| Test Case: GetNextRows - Tests Notifications for IRowset::GetNextRows
//| Created: 09/27/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetNextRows::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
if(CreateRowset(DEFAULT_ROWSET)==S_OK)
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) {} }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B,C) {} } "
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_4()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_5()
{
//Verify the FetchPosition did not change when the Veto occurs.
//Obtain the first row and veto. If method actually succeeds, the next
//GetNextRows will fail since it thinks that row has already been retreived...
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO} "
L" IRowset::GetNextRows(A) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_ACCEPT} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_6()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowset::GetNextRows(C,D,DB_E_NOTREENTRANT) {} }"
L" } "
L" } "
L"} ";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT - Non-notification method
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_7()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
// L" {L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IColumnsInfo::GetColumnInfo(DB_E_NOTREENTRANT){}}"
L" {L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.Thread{IColumnsInfo::GetColumnInfo(DB_E_NOTREENTRANT){}} }"
L" } "
L" } "
L"} ";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_8()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto OKTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_9()
{
//Have L1 VETO the change on the OKTODO phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO} "
L" } "
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_10()
{
//Have L1 VETO the change on the ABOUTTODO phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO} "
L" } "
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_11()
{
//Have L1 VETO the change on the SYNCHAFTER phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_VETO} "
L" } "
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_12()
{
//Have L1 VETO the change on the DIDEVENT phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_VETO} "
L" } "
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto FAILEDTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_13()
{
//Have L1 VETO the change on the OKTODO phase
//Then try and have it VETO the FAILEDTODO phase as well!
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" L1.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_VETO "
L" } "
L" } "
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto OKTODO, Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_14()
{
//Have L2 VETO the change on the OKTODO phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L2.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto ABOUTTODO, Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_15()
{
//Have L2 VETO the change on the ABOUTTODO phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto SYNCHAFTER, Listener 3
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_16()
{
//Have L3 VETO the change on the SYNCHAFTER phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_VETO} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_17()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_18()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNWANTEDREASON} "
L" IRowset::GetNextRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNWANTEDPHASE} "
L" IRowset::GetNextRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNWANTEDPHASE} "
L" IRowset::GetNextRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_UNWANTEDPHASE} "
L" IRowset::GetNextRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDENVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {L3.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_UNWANTEDPHASE} "
L" IRowset::GetNextRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" L3.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowset::GetNextRows(B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_25()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EFAIL "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_30()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_31()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) {} }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_33()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B,C) {} }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_34()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_35()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_36()
{
//Cannot "successfully" veto DIDEVENT, so there is really nothing
//to test on the Veto, besides making sure they are valid row
//handles, which is the purpose of the GetData's
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) "
L" {L3.ROW_ACTIVATE.DIDEVENT.RETURN_VETO} "
L" IRowset::GetData(A) {} "
L" IRowset::GetData(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_37()
{
//Have L1 Call GetNextRows on the DIDEVENT phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {"
L" L3.ROW_ACTIVATE.DIDEVENT.IRowset::GetNextRows(C,D,DB_E_NOTREENTRANT) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_38()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_39()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_40()
{
//Have L1 VETO the change on the DIDEVENT phase
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A,B) "
L" {"
L" L3.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_41()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_42()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_43()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {L3.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDREASON} "
L" IRowset::GetNextRows(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_44()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {L3.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDPHASE} "
L" IRowset::GetNextRows(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_45()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_46()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_47()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_48()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_49()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_50()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_51()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Fetch no rows - no notifications
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_52()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows() "
L" { "
L" } "
L" IRowset::GetNextRows() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Fetch A, Fetch A again
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_53()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowset::RestartPosition() {} "
L" IRowset::GetNextRows(A) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Fetch A, Fetch A,B
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_54()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowset::RestartPosition() {} "
L" IRowset::GetNextRows(A,B) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Fetch A, ReleaseRows A, Fetch A
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_55()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowset::ReleaseRows(A) {} "
L" IRowset::RestartPosition() {} "
L" IRowset::GetNextRows(A) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_56()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more than in rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_57()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(DB_S_ENDOFROWSET) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - 1 more at end of rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_58()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(DB_S_ENDOFROWSET) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowset::GetNextRows(A, DB_S_ENDOFROWSET) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(59)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - Stepping backward
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_59()
{
//TODO need some way to step backward?
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(DB_S_ENDOFROWSET) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(60)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_60()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(61)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADSTARTPOSITION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_61()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A, DB_E_BADSTARTPOSITION) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(62)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_62()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(E_INVALIDARG) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(63)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_63()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(DB_S_ENDOFROWSET) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(64)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_64()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNADVISE "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNADVISE "
L" } "
L" IRowset::GetNextRows(C) "
L" { "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(65)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_65()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ADVISE "
L" } "
L" IRowset::GetNextRows(B) "
L" { "
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_ADVISE "
L" } "
L" IRowset::GetNextRows(C) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(66)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetNextRows::Variation_66()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {IRowset::GetNextRows(A) "
L" { "
L" } "
L" IRowset::GetNextRows(B) "
L" {"
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowset::GetData(A) {} "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.IRowset::GetData(A) {} "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.IRowset::GetData(A) {} "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.IRowset::GetData(A) {} "
L" } "
L" IRowset::GetNextRows(C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(B) {} "
L" L2.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(A) {} "
L" L3.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(B) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetNextRows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(ReleaseRows)
//*-----------------------------------------------------------------------
//| Test Case: ReleaseRows - Tests Notifications for IRowset::ReleaseRows
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ReleaseRows::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
if(CreateRowset(DEFAULT_ROWSET)==S_OK)
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A) {} "
L" IRowset::ReleaseRows(A) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowset::ReleaseRows(A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_4()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - DB_E_CANCELED - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_5()
{
//Cannot "sucessfully" Veto a DIDEVENT reason, so just make sure the row
//handle is invalid after a veto of ROW_RELEASE
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A) {} "
L" IRowset::ReleaseRows(A) "
L" { "
L" L1.ROW_RELEASE.DIDEVENT.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - DB_E_NOTREENTRANT - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_6()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.IRowset::ReleaseRows(A, DB_E_NOTREENTRANT) {} } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_8()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - Veto DIDEVENT, Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A) {} "
L" IRowset::ReleaseRows(A) { L2.ROW_RELEASE.DIDEVENT.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_10()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_11()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.RETURN_UNWANTEDREASON } "
L" IRowset::ReleaseRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_13()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.RETURN_UNWANTEDPHASE } "
L" IRowset::ReleaseRows(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_15()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.RETURN_EFAIL } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.RETURN_EOUTOFMEMORY } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_RELEASE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) { L1.ROW_RELEASE.DIDEVENT.RETURN_EINVALIDARG } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_19()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Release 0 rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - AddRef Row, ReleaseRows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::AddRefRows(A,B) {} "
L" IRowset::ReleaseRows(A,B) {} "
L" IRowset::ReleaseRows(A,B) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - ReleaseRow, ReleaseRow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A,B) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - ReleaseRows [valid, invalid]
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A,B,C,DB_S_ERRORSOCCURRED) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_25()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_S_PENDINGCHANGES
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_26()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowset::ReleaseRows(A) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" L2.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" L3.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A, E_INVALIDARG) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::ReleaseRows(A,B,C,DB_E_ERRORSOCCURRED) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowset::ReleaseRows(A) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.RETURN_UNADVISE "
L" } "
L" IRowset::ReleaseRows(B) "
L" { "
L" L2.ROW_RELEASE.DIDEVENT.RETURN_UNADVISE "
L" } "
L" IRowset::ReleaseRows(C) "
L" { "
L" L3.ROW_RELEASE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ReleaseRows::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A) "
L" {"
L" L1.ROW_RELEASE.DIDEVENT.IRowset::GetData(B) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL ReleaseRows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(RestartPosition)
//*-----------------------------------------------------------------------
//| Test Case: RestartPosition - Tests Notificatons for IRowset::RestartPosition
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL RestartPosition::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
if(CreateRowset(DEFAULT_ROWSET)==S_OK)
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::RestartPosition() {} "
L" IRowset::RestartPosition() {} "
L" IRowset::RestartPosition() {} "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::ReleaseRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" IRowset::RestartPosition() {} "
L" IRowset::RestartPosition() {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_4()
{
//Need to verify the FETCHPOSITION did not get reset since it was veto'd
//Read all the rows in the rowset. Then Veto the RestartPostition().
//The next GetNextRows should fail, if the FetchPosition was truly veto'd
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(DB_S_ENDOFROWSET) {} "
L" IRowset::RestartPosition() { L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO } "
L" IRowset::GetNextRows(A, DB_S_ENDOFROWSET) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.IRowset::RestartPosition(DB_E_NOTREENTRANT) {} } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L2.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO } "
L" }"
L" }"
L"}";
//TODO need to verify the fetch position does not change!
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L2.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L2.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_VETO } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" L3.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L3.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNWANTEDREASON } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L3.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNWANTEDPHASE } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNWANTEDPHASE } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_UNWANTEDPHASE } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { L3.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_UNWANTEDPHASE } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() {} "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" L3.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowset::RestartPosition() {} "
L" IRowset::GetNextRows(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EFAIL "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_29()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_30()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.IRowset::RestartPosition() {} "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_33()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_34()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_35()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_36()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_37()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_38()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_VETO "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_39()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_VETO "
L" L1.ROWSET_CHANGED.FAILEDTODO.RETURN_VETO "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_CHANGED, DBEVENTPHASE_DIDEVENT));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_40()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_41()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_42()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_43()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_44()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_45()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_46()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_47()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_VETO "
L" L1.ROWSET_CHANGED.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_CHANGED, DBEVENTPHASE_OKTODO));
TESTC(Execute(CommandString, DEFAULT_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_48()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_49()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_50()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_EFAIL "
L" L2.ROWSET_CHANGED.ABOUTTODO.RETURN_EFAIL "
L" L3.ROWSET_CHANGED.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_EFAIL "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_51()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROWSET_CHANGED.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROWSET_CHANGED.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc ROWSET_CHANGED - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_52()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_EINVALIDARG "
L" L2.ROWSET_CHANGED.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROWSET_CHANGED.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROWSET_CHANGED.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" ITableDefinition::AddColumn() {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_CHANGED.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_53()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_54()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - RestartPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_55()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetNextRows - RestartPosition - RestartPosition
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_56()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_57()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_ROWSNOTRELEASED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_58()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
//TODO need to specifiy no CANHOLDROWS
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(59)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_59()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::RestartPosition() "
L" { "
L" } "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(60)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_60()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNADVISE "
L" L2.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_UNADVISE "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L3.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNADVISE "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(61)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RestartPosition::Variation_61()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowset::GetData(A) {} "
L" L2.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.IRowset::GetData(B) {} "
L" L3.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.IRowset::GetData(A) {} "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.IRowset::GetData(B) {} "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.IRowset::GetData(A) {} "
L" } "
L" IRowset::GetNextRows(A,B) {} "
L" IRowset::RestartPosition() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, DEFAULT_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL RestartPosition::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Seek)
//*-----------------------------------------------------------------------
//| Test Case: Seek - Test Notifications for IRowsetIndex::Seek
//| Created: 03/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Seek::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(ROWSETINDEX_ROWSET)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_4()
{
//Need to verify the Veto was successful
//Verify the FETCHPOSITION is unachanged after veto
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowsetIndex::Seek(1) {} "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" L1.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_OKTODO));
TESTC(Execute(CommandString, ROWSETINDEX_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" L1.ROWSET_FETCHPOSITIONCHANGE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROWSET_FETCHPOSITIONCHANGE, DBEVENTPHASE_OKTODO));
TESTC(Execute(CommandString, ROWSETINDEX_ROWSET));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EFAIL "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EFAIL "
L" L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc FETCHPOSITIONCHANGE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_EINVALIDARG "
L" L1.ROWSET_FETCHPOSITIONCHANGE.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROWSET_FETCHPOSITIONCHANGE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROWSET_FETCHPOSITIONCHANGE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1,DB_E_BADACCESSORHANDLE) "
L" { "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetIndex::Seek(1,DB_S_ENDOFROWSET) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_ADVISE "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L2.ROWSET_FETCHPOSITIONCHANGE.OKTODO.RETURN_UNADVISE "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Seek::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetIndex::Seek(1) "
L" { "
L" L1.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetIndex::Seek(1) "
L" { "
L" L2.ROWSET_FETCHPOSITIONCHANGE.OKTODO.IRowset::GetData(B) "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETINDEX_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Seek::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetRowsAt)
//*-----------------------------------------------------------------------
//| Test Case: GetRowsAt - Tests Notificatons for IRowsetLocate::GetRowsAt
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsAt::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(ROWSETLOCATE_ROWSET)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_4()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_5()
{
//Cannot "successfully" veto DIDEVENT
//Verify rows are valid after veto
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" }"
L" IRowset::GetData(A) {} "
L" IRowset::GetData(B) {} "
L" IRowset::GetData(C) {} "
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_6()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C, DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_8()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_10()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_11()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDREASON "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_13()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_15()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EFAIL "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EINVALIDARG "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_19()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Get same row twice
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADSTARTPOSITION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C, DB_E_BADSTARTPOSITION) "
L" {"
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, DB_S_ENDOFROWSET) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - more rows than are in the rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C,D,E, DB_S_ENDOFROWSET) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_LAST, A, DB_S_ENDOFROWSET) "
L" {"
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - no rows at head of rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_26()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST) "
L" {"
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - no rows at end of rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_LAST) "
L" {"
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNADVISE "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B,C) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAt::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A) {} "
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(A) {} "
L" }"
L" IRowsetLocate::GetRowsAt(DBBMK_FIRST, A) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsAt::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetRowsByBookmark)
//*-----------------------------------------------------------------------
//| Test Case: GetRowsByBookmark - Tests Notifications for IRowsetLocate::GetRowsbyBookmark
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsByBookmark::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(ROWSETLOCATE_ROWSET)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A) {} "
L" IRowset::ReleaseRows(A) {} "
L" IRowsetLocate::GetRowsByBookmark(A) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsByBookmark(A) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsByBookmark(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_4()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_5()
{
//Need to verify the Veto was successful
//Verify rows are not valid after veto
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetLocate::GetRowsByBookmark(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_6()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowsetLocate::GetRowsByBookmark(A,B,DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetLocate::GetRowsByBookmark(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_8()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetLocate::GetRowsByBookmark(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_10()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_11()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDREASON "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_13()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_15()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EFAIL "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(A,B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EINVALIDARG "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_19()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Get no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark() "
L" {"
L" }"
L" IRowsetLocate::GetRowsByBookmark(B,C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Get same row twice
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(B,E_INVALIDARG) "
L" {"
L" }"
L" IRowsetLocate::GetRowsByBookmark(C) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetLocate::GetRowsByBookmark(B, DB_E_ERRORSOCCURRED) "
L" {"
L" }"
L" IRowsetLocate::GetRowsByBookmark(C, DB_E_ERRORSOCCURRED) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNADVISE "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C) "
L" {"
L" L2.ROW_ACTIVATE.DIDEVENT.RETURN_UNADVISE "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsByBookmark::Variation_26()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowset::ReleaseRows(A,B,C,D) {} "
L" IRowsetLocate::GetRowsByBookmark(B) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(B) {} "
L" }"
L" IRowsetLocate::GetRowsByBookmark(C) "
L" {"
L" L1.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(C) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETLOCATE_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsByBookmark::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetRowsAtRatio)
//*-----------------------------------------------------------------------
//| Test Case: GetRowsAtRatio - Test Nofications for IRowsetScroll::GetRowsAtRatio
//| Created: 03/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsAtRatio::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(ROWSETSCROLL_ROWSET)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_4()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_5()
{
//Veriy the veto was successful
//Row should be unaffected by the resynch
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_6()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.IRowsetScroll::GetRowsAtRatio(1,A,B,C,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_8()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - Veto DIDEVENT, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_10()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_11()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_13()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_15()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_ACTIVATE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_19()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - No rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1) "
L" { "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET 1 more than rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1, A,B,C,D, DB_S_ENDOFROWSET) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1, A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_S_ENDOFROWSET - at end of rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1, A,B,C, DB_S_ENDOFROWSET) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1, A,B,C, DB_S_ENDOFROWSET) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1, DB_S_ENDOFROWSET) "
L" { "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1, DB_S_ENDOFROWSET) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.RETURN_UNADVISE "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetRowsAtRatio::Variation_26()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowset::ReleaseRows(A,B,C) {} "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C) "
L" { "
L" L1.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(A) {} "
L" L2.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(B) {} "
L" L3.ROW_ACTIVATE.DIDEVENT.IRowset::GetData(C) {} "
L" } "
L" IRowsetScroll::GetRowsAtRatio(1,A,B,C,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, ROWSETSCROLL_ROWSET);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetRowsAtRatio::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(DeleteRows)
//*-----------------------------------------------------------------------
//| Test Case: DeleteRows - Tests Notifications for IRowsetChange::DeleteRows
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL DeleteRows::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_IMMEDIATE)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" } "
L" } "
L"}";
TableInsert(ONE_ROW); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_4()
{
//Need to make sure the Veto of ROW_DELETE did not delete the row
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.IRowsetChange::DeleteRows(B, DB_E_NOTREENTRANT) {} "
L" } "
L" } "
L" } "
L"}";
TableInsert(ONE_ROW); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto OKTODO Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto SYNCHAFTER Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L2.ROW_DELETE.SYNCHAFTER.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto DIDEVENT Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto FAILEDTODO Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_DELETE.FAILEDTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners - SINGLEROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_13()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_UNADVISE "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_ADVISE "
L" } "
L" IRowsetChange::DeleteRows(B) "
L" { "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData - SINGLEROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_14()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.IRowset::GetData(A) {} "
L" L3.ROW_DELETE.ABOUTTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetChange::DeleteRows(B) "
L" { "
L" L3.ROW_DELETE.OKTODO.IRowset::GetData(B) {} "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_DELETE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(C,D) {} "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TableInsert(FOUR_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_DELETED - SINGLEROW
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_21()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::DeleteRows(A,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" } "
L" } "
L"}";
TableInsert(ONE_ROW); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EFAIL "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::DeleteRows(B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EFAIL "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
//TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TableInsert(FOUR_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(FOUR_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Veto ABOUTTODO Listener 1 - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
TableInsert(FOUR_ROWS); //Compensate for the deleted row(s)
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_26()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::DeleteRows(B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::DeleteRows(B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Delete no rows, Delete MULTIPLEROWS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_DELETED - MULTIPLEROWS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::DeleteRows(A,B,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" } "
L" } "
L"}";
TableInsert(TWO_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, EMPTY_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners - MULTIPLEROWS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_UNADVISE "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_ADVISE "
L" } "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" } "
L" } "
L" } "
L"}";
TableInsert(THREE_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData - MULTIPLEROWS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.IRowset::GetData(A) {} "
L" L3.ROW_DELETE.ABOUTTODO.IRowset::GetData(B) {} "
L" } "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L3.ROW_DELETE.OKTODO.IRowset::GetData(C) {} "
L" } "
L" } "
L" } "
L"}";
TableInsert(THREE_ROWS); //Compensate for the deleted row(s)
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL DeleteRows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(DeleteRows_Bufferred)
//*-----------------------------------------------------------------------
//| Test Case: DeleteRows_Bufferred - Test Notifications for IRowsetChange::DeleteRows in Buffered Mode
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL DeleteRows_Bufferred::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - SINGLEROW - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - MULTIPLEROWS - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_2()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_4()
{
//Need to make sure the Veto of ROW_DELETE did not delete the row
//Make sure row is valid after Veto
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.IRowsetChange::DeleteRows(B, DB_E_NOTREENTRANT) {} "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - Veto OKTODO Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - Veto ABOUTTODO Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - Veto SYNCHAFTER Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L2.ROW_DELETE.SYNCHAFTER.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - Veto DIDEVENT Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - Veto FAILEDTODO Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_DELETE.FAILEDTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(B) {} "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_DELETE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::DeleteRows(C,D) {} "
L" } "
L" } "
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_DELETE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EFAIL "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_DELETE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(A,B) "
L" { "
L" L1.ROW_DELETE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROW_DELETE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_DELETE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::DeleteRows(C,D) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Delete no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L2.ROW_DELETE.OKTODO.RETURN_ACCEPT "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_DELETED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L2.ROW_DELETE.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::DeleteRows(C,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" { "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" IRowsetChange::DeleteRows() "
L" { "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L2.ROW_DELETE.OKTODO.RETURN_UNADVISE "
L" L3.ROW_DELETE.SYNCHAFTER.RETURN_UNADVISE "
L" } "
L" IRowsetChange::DeleteRows(D) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.RETURN_UNADVISE "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L2.ROW_DELETE.OKTODO.IRowset::GetData(C) {} "
L" L3.ROW_DELETE.ABOUTTODO.IRowset::GetData(C) {} "
L" } "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.ABOUTTODO.IRowset::GetData(D) {} "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetOriginalData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int DeleteRows_Bufferred::Variation_33()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" { "
L" IRowset::GetNextRows(A,B,C,D) {} "
L" IRowsetChange::DeleteRows(C) "
L" { "
L" L2.ROW_DELETE.OKTODO.IRowsetUpdate::GetOriginalData(C,DB_E_NOTREENTRANT) {} "
L" L3.ROW_DELETE.SYNCHAFTER.IRowsetUpdate::GetOriginalData(C,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetChange::DeleteRows(A) "
L" { "
L" L1.ROW_DELETE.DIDEVENT.IRowsetUpdate::GetOriginalData(D,DB_E_NOTREENTRANT) {} "
L" } "
L" } "
L" } "
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL DeleteRows_Bufferred::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(InsertRow)
//*-----------------------------------------------------------------------
//| Test Case: InsertRow - Tests Notifications for IRowsetChange::InsertRow
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL InsertRow::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_IMMEDIATE)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_4()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowsetChange::InsertRow(C, DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_5()
{
//Make sure the Veto of InsertRow actually occrrued.
//Row handle should not be valid after delete
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetChange::SetData(A,2,DB_E_BADROWHANDLE) {} "
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto OKTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto ABOUTTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto SYNCHAFTER, Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L2.ROW_INSERT.SYNCHAFTER.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto DIDEVENT, Listener 3
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto FAILEDTODO, Listener 3
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_INSERT.FAILEDTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_INSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_14()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNWANTEDREASON "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.DIDEVENT.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_INSERT.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_INSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EFAIL "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EFAIL "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EOUTOFMEMORY "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EINVALIDARG "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_25()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A,DB_E_BADACCESSORHANDLE) "
L" {"
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ADVISE "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNADVISE "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A) {} "
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowset::GetData(A) {} "
L" }"
L" IRowset::GetData(A) {} "
L" IRowsetChange::InsertRow(C) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowset::GetData(B) {} "
L" }"
L" IRowset::GetData(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL InsertRow::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(InsertRow_Bufferred)
//*-----------------------------------------------------------------------
//| Test Case: InsertRow_Bufferred - Test Notifications for IRowsetChange::InsertRow in Buffered Mode
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL InsertRow_Bufferred::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_4()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowsetChange::InsertRow(C, DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_5()
{
//Need to make sure the Veto was successful
//Row should not be valid after insert
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetChange::SetData(A,2,DB_E_BADROWHANDLE) {} "
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto OKTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto ABOUTTODO, Listener 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto SYNCHAFTER, Listener 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L2.ROW_INSERT.SYNCHAFTER.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto DIDEVENT, Listener 3
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - Veto FAILEDTODO, Listener 3
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_INSERT.FAILEDTODO.RETURN_VETO "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_INSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_14()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNWANTEDREASON "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.DIDEVENT.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_INSERT.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetChange::InsertRow(B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_INSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EFAIL "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EFAIL "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EOUTOFMEMORY "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_INSERT - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_INSERT.DIDEVENT.RETURN_EINVALIDARG "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_25()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_27()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A,DB_E_BADACCESSORHANDLE) "
L" {"
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.ABOUTTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) "
L" {"
L" L1.ROW_INSERT.OKTODO.RETURN_UNADVISE "
L" }"
L" IRowsetChange::InsertRow(B) "
L" {"
L" L2.ROW_INSERT.OKTODO.RETURN_ADVISE "
L" L3.ROW_INSERT.OKTODO.RETURN_UNADVISE "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) {} "
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowset::GetData(A) {} "
L" }"
L" IRowsetChange::InsertRow(C) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowset::GetData(A) {} "
L" L2.ROW_INSERT.OKTODO.IRowset::GetData(B) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetOriginalData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int InsertRow_Bufferred::Variation_31()
{
// From the spec:
//GetOriginalData() gets the data most recently fetched from or transmitted to the data store;
//does not get values based on pending changes => we can not call GetOriginalData for newly inserted row untill it's transmeted
//Commented out this variation
/* WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetChange::InsertRow(A) {} "
L" IRowsetChange::InsertRow(B) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetChange::InsertRow(C) "
L" {"
L" L1.ROW_INSERT.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" L2.ROW_INSERT.OKTODO.IRowsetUpdate::GetOriginalData(B,DB_E_NOTREENTRANT) {} "
L" L3.ROW_INSERT.DIDEVENT.IRowsetUpdate::GetOriginalData(C,DB_E_NOTREENTRANT) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
*/
return TEST_SKIPPED;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL InsertRow_Bufferred::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(SetData)
//*-----------------------------------------------------------------------
//| Test Case: SetData - Tests Notifications for IRowsetChange::SetData
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL SetData::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_IMMEDIATE)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_4()
{
//Need to make sure the Veto was successful
//RowData should not have been altered after veto, GetData will ensure this
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) { L1.COLUMN_SET.OKTODO.IRowsetChange::SetData(A,2,DB_E_NOTREENTRANT) {} } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) { L1.COLUMN_SET.OKTODO.RETURN_VETO } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) { L1.COLUMN_SET.ABOUTTODO.RETURN_VETO } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) { L1.COLUMN_SET.SYNCHAFTER.RETURN_VETO } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) { L1.COLUMN_SET.DIDEVENT.RETURN_VETO } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" L1.COLUMN_SET.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_COLUMN_SET, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_14()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE ABOUTTO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET- UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" L1.COLUMN_SET.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_COLUMN_SET, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_20()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_22()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L3.COLUMN_SET.OKTODO.RETURN_EFAIL "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EFAIL "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_EFAIL "
L" L3.COLUMN_SET.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L3.COLUMN_SET.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L3.COLUMN_SET.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L3.COLUMN_SET.OKTODO.RETURN_EINVALIDARG "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_EINVALIDARG "
L" L3.COLUMN_SET.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_25()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - DB_E_ERRORSOCCURRED - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_27()
{
//Try to change the Data for the computed column.
//Should get DB_E_ERRORSOCCURRED with no notifications
//We need the only computed column is been modified in SetData to be sure
//that modification of the computed column causes an error (and not other columns)
//so use special mode COMPUTED_COLUMNS_INCLUDE (only one column will be included to m_rgUpBindings)
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" IRowsetChange::SetData(A,2,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS_INCLUDE | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_28()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_29()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_30()
{
//Need to make sure the Veto was successful
//RowData should not have been altered after veto, GetData will ensure this
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.IRowsetChange::SetData(A,2,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_32()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_33()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_34()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_35()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_36()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_37()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_38()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_39()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_40()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_41()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_42()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_43()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_44()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_45()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_46()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,DB_E_BADACCESSORHANDLE) "
L" { "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_47()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetChange::SetData(A,2,DB_E_BADROWHANDLE) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_48()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_ADVISE "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.DIDEVENT.RETURN_UNADVISE "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData::Variation_49()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetChange::SetData(B,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowset::GetData(A) {} "
L" L2.COLUMN_SET.ABOUTTODO.IRowset::GetData(B) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL SetData::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(SetData_Bufferred)
//*-----------------------------------------------------------------------
//| Test Case: SetData_Bufferred - Test Notifications for IRowsetChange::SetData in Buffered Mode
//| Created: 03/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL SetData_Bufferred::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - InsertRow(A), SetData(A) - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_4()
{
//Need to make sure the Veto was successful
//FIRSTCHANGE should be fired again
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.IRowsetChange::SetData(A,2,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_FIRSTCHANGE.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_FIRSTCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_FIRSTCHANGE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(B,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_FIRSTCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_EFAIL "
L" L2.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_EFAIL "
L" L3.ROW_FIRSTCHANGE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_FIRSTCHANGE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::SetData(B,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.ROW_FIRSTCHANGE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_FIRSTCHANGE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::SetData(B,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_FIRSTCHANGE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_EINVALIDARG "
L" L2.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.ROW_FIRSTCHANGE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_FIRSTCHANGE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::SetData(B,2) "
L" { "
L" L1.ROW_FIRSTCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_29()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_30()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_31()
{
//Need to verify the Veto was successful
//SetData should not have modified the row, GetData will verify this
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowsetChange::SetData(A,2,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_33()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_34()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_35()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_36()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_37()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_38()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_39()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" L1.COLUMN_SET.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_FIRSTCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_40()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_41()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_42()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE ABOUTTO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_43()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_44()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET- UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_45()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_46()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" L1.COLUMN_SET.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_FIRSTCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_47()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_48()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_49()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_EFAIL "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EFAIL "
L" L3.COLUMN_SET.SYNCHAFTER.RETURN_EFAIL "
L" L1.COLUMN_SET.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_50()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_EOUTOFMEMORY "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L3.COLUMN_SET.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.COLUMN_SET.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_SET - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_51()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_EINVALIDARG "
L" L2.COLUMN_SET.ABOUTTODO.RETURN_EINVALIDARG "
L" L3.COLUMN_SET.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.COLUMN_SET.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_52()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_53()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_54()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_55()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_56()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_57()
{
//Need to make sure the Veto was successful
//RowData should not have been altered after veto, GetOriginalData will ensure this
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetUpdate::GetOriginalData(A) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_58()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.IRowsetUpdate::Update(A) {} "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(59)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_59()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(60)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_60()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(61)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_61()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(62)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_62()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(63)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_63()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(64)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_64()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) {} "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(65)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_65()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) {} "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(66)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_66()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(67)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_67()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(68)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_68()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(69)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_69()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(70)
//*-----------------------------------------------------------------------
// @mfunc COLUMN_RECALCULATED - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_70()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetChange::SetData(A,2) {} "
L" IRowsetUpdate::Update(A) "
L" { "
L" L1.COLUMN_RECALCULATED.DIDEVENT.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
//COMPUTED_COLUMNS - makes the first column the input and
//the second column the computed column (col1-col2).
return Execute(CommandString, COMPUTED_COLUMNS | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(71)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_71()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(72)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_72()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(73)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DB_E_BADACCESSORHANDLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_73()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,DB_E_BADACCESSORHANDLE) "
L" { "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(74)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_74()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowsetChange::SetData(A,2,DB_E_BADROWHANDLE) "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(75)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_75()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_UNADVISE "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.RETURN_ADVISE "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(76)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_76()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowset::GetData(A) {} "
L" L2.COLUMN_SET.ABOUTTODO.IRowset::GetData(B) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(77)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetOriginalData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SetData_Bufferred::Variation_77()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetChange::SetData(A,2) "
L" { "
L" L1.COLUMN_SET.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" L2.COLUMN_SET.ABOUTTODO.IRowsetUpdate::GetOriginalData(B,DB_E_NOTREENTRANT) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL SetData_Bufferred::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Resynch)
//*-----------------------------------------------------------------------
//| Test Case: Resynch - Tests Notifications for IRowsetResynch::ResyncRows
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Resynch::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(RESYNCH_ROWSET | CHANGE_IMMEDIATE)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_4()
{
//Need to verify the Veto was successful
//Verify rows are unchanged by resynch
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::ResynchRows(A,B,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" L1.ROW_RESYNCH.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_RESYNCH, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" L1.ROW_RESYNCH.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_RESYNCH, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EFAIL "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Resynch all rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows() "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Resynch 2 rows, 1 changed 1 not changed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - 1 valid, 1 not valid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,C,DB_S_ERRORSOCCURRED) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetResynch::ResynchRows() "
L" { "
L" } "
L" IRowsetResynch::ResynchRows() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNADVISE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L2.ROW_RESYNCH.OKTODO.RETURN_UNADVISE "
L" L3.ROW_RESYNCH.OKTODO.RETURN_UNADVISE "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_33()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowset::GetData(B) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetVisibleData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch::Variation_34()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::GetVisibleData(A, DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::GetVisibleData(B, DB_E_NOTREENTRANT) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_IMMEDIATE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Resynch::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Resynch_Bufferred)
//*-----------------------------------------------------------------------
//| Test Case: Resynch_Bufferred - Tests Notifications for IRowsetResynch_Bufferred::ResyncRows
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Resynch_Bufferred::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(RESYNCH_ROWSET | CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_4()
{
//Veriy the veto was successful
//Row should be unaffected by the resynch
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(A) {} "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::ResynchRows(A,B,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" L1.ROW_RESYNCH.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_RESYNCH, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" L1.ROW_RESYNCH.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_RESYNCH, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EFAIL "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_RESYNCH - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_RESYNCH.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Resynch_Bufferred all rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetResynch::ResynchRows() "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows() "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Resynch_Bufferred 2 rows, 1 changed 1 not changed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - 1 valid, 1 not valid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,C,DB_S_ERRORSOCCURRED) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_31()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetResynch::ResynchRows() "
L" { "
L" } "
L" IRowsetResynch::ResynchRows() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_ADVISE "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.RETURN_UNADVISE "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_33()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowset::GetData(A) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowset::GetData(B) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetVisibleData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Resynch_Bufferred::Variation_34()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::GetVisibleData(A, DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetResynch::ResynchRows(A,B) "
L" { "
L" L1.ROW_RESYNCH.OKTODO.IRowsetResynch::GetVisibleData(B, DB_E_NOTREENTRANT) {} "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, RESYNCH_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Resynch_Bufferred::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Undo)
//*-----------------------------------------------------------------------
//| Test Case: Undo - Tests Notifications for IRowsetUpdate::Undo
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Undo::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_4()
{
//Veriy the veto was successful
//Row should be unaffected by the Undo
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(B) {} "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.IRowsetUpdate::Undo(B,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_9()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_12()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDOCHANGE.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDOCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDOCHANGE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(B,C) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDOCHANGE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_EFAIL "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_UNDOCHANGE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOCHANGE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOCHANGE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::SetData(C,2,5) {} "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDOCHANGE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_UNDOCHANGE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_29()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_30()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_31()
{
//Veriy the veto was successful
//Row should be unaffected by the Undo
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowset::GetData(C) {} "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.IRowsetUpdate::Undo(C,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_33()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_34()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_35()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_36()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_37()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_38()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_39()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDOINSERT.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDOINSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_40()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_41()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_42()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - UNWANTED PHASE ABOUTTO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_43()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_44()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT- UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_45()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_46()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDOINSERT.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(D) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDOINSERT, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_47()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_48()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_49()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_EFAIL "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_UNDOINSERT.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_UNDOINSERT.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetUpdate::Undo(D) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_50()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOINSERT.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDOINSERT.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetUpdate::Undo(D) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDOINSERT - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_51()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::DeleteRows(A) {} "
L" IRowsetChange::SetData(D,2,5) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" L1.ROW_UNDOINSERT.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDOINSERT.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_UNDOINSERT.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetUpdate::Undo(D) "
L" { "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_52()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_53()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_54()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_ACCEPT "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_55()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_56()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_57()
{
//Veriy the veto was successful
//Row should be unaffected by the Undo
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetChange::DeleteRows(A,DB_E_ERRORSOCCURRED) {} "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_58()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.IRowsetUpdate::Undo(A,B,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(59)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_59()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(60)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_60()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(61)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_61()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(62)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_62()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(63)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_63()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.SYNCHAFTER.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(64)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_64()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.DIDEVENT.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(65)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_65()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDODELETE.FAILEDTODO.RETURN_VETO "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDODELETE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(66)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_66()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(67)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_67()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(68)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_68()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_UNWANTEDREASON "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(69)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED PHASE OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_69()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(70)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED PHASE ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_70()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(71)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED PHASE SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_71()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(72)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED PHASE DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_72()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(73)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - UNWANTED PHASE FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_73()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UNDODELETE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" } "
L" IRowsetUpdate::Undo(A,B) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UNDODELETE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(74)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_74()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(75)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_75()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(76)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_76()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_EFAIL "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_UNDODELETE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_UNDODELETE.DIDEVENT.RETURN_EFAIL "
L" } "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(77)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_77()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDODELETE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_UNDODELETE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" } "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(78)
//*-----------------------------------------------------------------------
// @mfunc ROW_UNDODELETE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_78()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B) {} "
L" IRowsetChange::InsertRow(C) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(A,B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDODELETE.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_UNDODELETE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_UNDODELETE.DIDEVENT.RETURN_EINVALIDARG "
L" } "
L" IRowsetUpdate::Undo(B) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_VETO "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(79)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_79()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(80)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_80()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(81)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Undo unchanged row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_81()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(C) "
L" { "
L" } "
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(82)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Undo all rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_82()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo() "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(83)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Undo changed and unchanged
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_83()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(A,B,C,D) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(84)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_84()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(85)
//--------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Verify Undo clears the FIRSTCHANGE status
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_85()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::SetData(A,2) "
L" {"
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetUpdate::Undo(A) "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" IRowsetChange::SetData(A,2) "
L" {"
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(86)
//--------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_86()
{
// TO DO: Add your own code here
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(87)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_E_INVALID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_87()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(E,DB_E_ERRORSOCCURRED) "
L" { "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" L1.ROW_UNDOCHANGE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_ACCEPT "
L" L1.ROW_UNDOINSERT.ABOUTTODO.RETURN_ACCEPT "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(88)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_88()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(89)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_89()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(A,B,C,D) "
L" { "
L" L1.ROW_UNDODELETE.ABOUTTODO.RETURN_ADVISE "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(90)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_90()
{
//From the spec: in delayed update mode rows with pending deletes cannot be used in GetData
//Povider may return DB_E_DELETEDROW from GetData if hRow referred to a pending delete row, but
//providers are not required to check for this condition and result of passing an invalid row handle in hRow is undefined
//=>Commented out L1.ROW_UNDODELETE.ABOUTTODO.IRowset::GetData(B)
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(A,B,C,D) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.IRowset::GetData(A) {} "
// L" L1.ROW_UNDODELETE.ABOUTTODO.IRowset::GetData(B) {} "
L" L1.ROW_UNDODELETE.SYNCHAFTER.IRowset::GetData(B) {} "
L" L3.ROW_UNDOINSERT.ABOUTTODO.IRowset::GetData(D) {} "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(91)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetOriginalData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Undo::Variation_91()
{
//Form the spec:
//GetOriginalData gets the data most recently fetched from or transmitted to the data store
//=> for newly inserted row in delayed update mode we can not call GetOriginalData untill it's transmitted
//=> commented out L3.ROW_UNDOINSERT.ABOUTTODO.IRowsetUpdate::GetOriginalData(D,DB_E_NOTREENTRANT)
WCHAR CommandString[] =
L"{Listener L1; Listener L2; Listener L3; "
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetUpdate::Undo(A,B,C,D) "
L" { "
L" L1.ROW_UNDOCHANGE.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" L1.ROW_UNDODELETE.ABOUTTODO.IRowsetUpdate::GetOriginalData(B,DB_E_NOTREENTRANT) {} "
// L" L3.ROW_UNDOINSERT.ABOUTTODO.IRowsetUpdate::GetOriginalData(D,DB_E_NOTREENTRANT) {} "
L" } "
L" IRowsetUpdate::Undo() "
L" { "
L" } "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Undo::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Update)
//*-----------------------------------------------------------------------
//| Test Case: Update - Tests Notifications for IRowsetUpdate::Update
//| Created: 09/29/96
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Update::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(CExecutionManager::Init())
// }}
{
//Verify Rowset can be created...
TEST_PROVIDER(CreateRowset(CHANGE_BUFFERRED)==S_OK);
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Accept all phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_1()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetUpdate::Update(A,D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_3()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - DB_E_CANCELED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_4()
{
//Veriy the veto was successful
//Row should be unaffected by the Update
//Make sure Veto of the first setdata, doesn't affect the Update
//of the second setdata
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetUpdate::GetOriginalData(A) {} "
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - DB_E_NOTREENTRANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_5()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.IRowsetUpdate::Update(A,B,C,DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_6()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_7()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Veto OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_8()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_VETO "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Veto ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_9()
{
//Make sure Veto of the first insert, doesn't affect the Update
//of the second insert
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::InsertRow(E) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(D,E,A) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" }"
L" IRowsetUpdate::Update(C) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Veto SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_10()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.SYNCHAFTER.RETURN_VETO "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Veto DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_11()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.DIDEVENT.RETURN_VETO "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - Veto FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_12()
{
//Make sure Veto of the first delete, doesn't affect the Update
//of the second delete
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::DeleteRows(B) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(B,C,A) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UPDATE.FAILEDTODO.RETURN_VETO "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UPDATE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_13()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_14()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED REASON
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_15()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_UNWANTEDREASON "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED PHASE - OKTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_16()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED PHASE - ABOUTTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_17()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED PHASE - SYNCHAFTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_18()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.SYNCHAFTER.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED PHASE - DIDEVENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_19()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.DIDEVENT.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - UNWANTED PHASE - FAILEDTODO
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_20()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" L1.ROW_UPDATE.FAILEDTODO.RETURN_UNWANTEDPHASE "
L" }"
L" IRowsetUpdate::Update(D) {} "
L" }"
L" }"
L"}";
//To produce FAILEDTODO, this reason/phase must be vetoable...
TESTC_PROVIDER(IsCancelableEvent(DBREASON_ROW_UPDATE, DBEVENTPHASE_ABOUTTODO));
TESTC(Execute(CommandString, CHANGE_BUFFERRED));
CLEANUP:
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_21()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_22()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - E_FAIL - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_23()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_EFAIL "
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_EFAIL "
L" L1.ROW_UPDATE.SYNCHAFTER.RETURN_EFAIL "
L" L1.ROW_UPDATE.DIDEVENT.RETURN_EFAIL "
L" }"
L" IRowsetUpdate::Update(C,D) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - E_OUTOFMEMORY - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_24()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_EOUTOFMEMORY "
L" L1.ROW_UPDATE.SYNCHAFTER.RETURN_EOUTOFMEMORY "
L" L1.ROW_UPDATE.DIDEVENT.RETURN_EOUTOFMEMORY "
L" }"
L" IRowsetUpdate::Update(C,D) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc ROW_UPDATE - E_INVALIDARG - All Phases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_25()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_EINVALIDARG "
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_EINVALIDARG "
L" L1.ROW_UPDATE.SYNCHAFTER.RETURN_EINVALIDARG "
L" L1.ROW_UPDATE.DIDEVENT.RETURN_EINVALIDARG "
L" }"
L" IRowsetUpdate::Update(C,D) "
L" {"
L" L1.ROW_UPDATE.ABOUTTODO.RETURN_VETO "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_26()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_27()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Update all [no changes]
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_28()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetUpdate::Update() "
L" {"
L" }"
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Update all [changes]
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_29()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(D) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetUpdate::Update(D) "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Update changed and unchanged
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_30()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetUpdate::Update(A,B,D) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_31()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//--------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Verify Update clears FIRSTCHANGE status
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_32()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::SetData(A,2) "
L" {"
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetUpdate::Update(A) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" IRowsetChange::SetData(A,2) "
L" {"
L" L1.ROW_FIRSTCHANGE.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//--------------------------------------------------------------------
// @mfunc Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_33()
{
// TO DO: Add your own code here
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - DBROWSTATUS_E_INVALID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_34()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(E,DB_E_ERRORSOCCURRED) "
L" {"
L" }"
L" IRowsetUpdate::Update(C,D) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ACCEPT "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - EmptyRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_35()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowsetUpdate::Update() "
L" {"
L" }"
L" IRowsetUpdate::Update() "
L" {"
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, EMPTY_ROWSET | CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - Add/Remove Listeners
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_36()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_ADVISE "
L" }"
L" IRowsetUpdate::Update(C,D) "
L" {"
L" L1.ROW_UPDATE.OKTODO.RETURN_UNADVISE "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_37()
{
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B,C) "
L" {"
L" L1.ROW_UPDATE.OKTODO.IRowset::GetData(A) {} "
L" L1.ROW_UPDATE.OKTODO.IRowset::GetData(B) {} "
L" }"
L" IRowsetUpdate::Update(D) "
L" {"
L" L1.ROW_UPDATE.OKTODO.IRowset::GetData(D) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc OTHER SCENARIOS - GetOriginalData
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Update::Variation_38()
{
//Form the spec:
//GetOriginalData "gets the data most recently fetched from or transmitted to the data store;
//does not get values based on pending changes"
//=> for newly inserted row in delayed update mode we can not call GetOriginalData until it's transmitted
//=> commented out L1.ROW_UPDATE.OKTODO.IRowsetUpdate::GetOriginalData(D,DB_E_NOTREENTRANT)
WCHAR CommandString[] =
L"{Listener L1; Listener L2;"
L" {Control Control1;"
L" {"
L" IRowset::GetNextRows(A,B,C) {} "
L" IRowsetChange::InsertRow(D) {} "
L" IRowsetChange::SetData(A,2,5) {} "
L" IRowsetChange::SetData(B,2,5) {} "
L" IRowsetChange::DeleteRows(C) {} "
L" IRowsetUpdate::Update(A,B) "
L" {"
L" L1.ROW_UPDATE.OKTODO.IRowsetUpdate::GetOriginalData(A,DB_E_NOTREENTRANT) {} "
L" L1.ROW_UPDATE.OKTODO.IRowsetUpdate::GetOriginalData(B,DB_E_NOTREENTRANT) {} "
L" }"
L" IRowsetUpdate::Update(D) "
L" {"
// L" L1.ROW_UPDATE.OKTODO.IRowsetUpdate::GetOriginalData(D,DB_E_NOTREENTRANT) {} "
L" }"
L" }"
L" }"
L"}";
return Execute(CommandString, CHANGE_BUFFERRED);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Update::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(CExecutionManager::Terminate());
} // }}
// }}
// }}
Reference in New Issue View Git Blame Copy Permalink