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

14014 lines
389 KiB
C++
Raw Blame History

//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright 1995-2000 Microsoft Corporation.
//
// @doc
//
// @module IROWFIND.CPP | Template source file for all test modules.
//
#include "modstandard.hpp"
#define DBINITCONSTANTS // Must be defined to initialize constants in OLEDB.H
#define INITGUID
#include "irowfind.h"
#include <float.h>
#include <msdaguid.h> // CLSID_OLEDB_CONVERSIONLIBRARY
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0x9eb41234, 0x15cc, 0x11d1, { 0xa8, 0x7f, 0x00, 0xc0, 0x4f, 0xd7, 0xa0, 0xf5 }};
DECLARE_MODULE_NAME("IRowsetFind");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("Tests the IRowsetFind interface");
DECLARE_MODULE_VERSION(795921705);
// TCW_WizardVersion(2)
// TCW_Automation(True)
// }} TCW_MODULE_GLOBALS_END
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Globals
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CTable * g_pCTable=NULL; //Global table
CTable * g_pEmptyTable = NULL; //Empty table
CTable * g_p1RowTable = NULL; //One row table
IDBCreateSession * g_pIDBCreateSession = NULL; //pointer to IDBCreateSession interface
IDBCreateCommand * g_pIDBCreateCommand = NULL; //pointer to IDBCreateComand interface
DBORDINAL g_ulColNum; // Column number to test FindValue match on.
DBTYPE g_wColType; // DBTYPE of that column
DBROWCOUNT g_lRowLast; // the index of last row in g_pCTable.
LONG_PTR g_lNullCollation; // contains the value of the NULL_COLLATION property
ULONG g_ulDCVer = 0x200;
// Interface for IDataConvert, gotten by CoCreateInstance
IDataConvert * g_pIDataConvert=NULL;
enum ePrptIdx
{
IDX_Bookmarks=0,
IDX_OrderedBookmarks,
IDX_LiteralBookmarks,
IDX_FetchBackwards,
IDX_ScrollBackwards,
IDX_CanHoldRows,
IDX_RemoveDeleted,
IDX_BookmarkSkipped,
IDX_OtherUpdateDelete,
IDX_OtherInsert,
IDX_BookmarkType,
IDX_IRowsetDeleteBookmarks,
IDX_IRowsetChange,
IDX_IRowsetLocate
};
enum eSUBCOMPAREOP
{
SUBOP_EMPTY,
SUBOP_ALWAYS_EQ,
SUBOP_CONTAINS_BEGIN,
SUBOP_CONTAINS_MIDDLE,
SUBOP_CONTAINS_END,
SUBOP_CASESENSITIVE,
SUBOP_CASEINSENSITIVE,
SUBOP_ALWAYS_NULL
};
#define PROPERTY_COUNT IDX_IRowsetLocate+1
//record the properties default values
struct DBPrptRecord
{
BOOL fSupported;
BOOL fDefault;
} g_rgDBPrpt[PROPERTY_COUNT];
struct FindValueInfo
{
DBSTATUS dbsStatus;
DBLENGTH cbLength;
void *pValue;
};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Defines
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#define RESTART TRUE
#define USE_STREAM TRUE
#define USE_DBTYPE_EMPTY TRUE
#define TESTC_DRIVER(exp) { if((exp)==FALSE) { odtLog << L"NotSupported by Driver, skipping Variation\n"; fTestPass=TEST_SKIPPED; goto CLEANUP; } }
inline ULONG MYABS(short s)
{
return ( s >= 0 ? s : -s );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// prototypes
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
static BOOL IsDBTYPEFindable(DBTYPE wType);
static void FindVariantTypes(IRowset *pIRowset, CTable *pTable);
// Return TRUE for only DBTYPEs that match an OLE VARIANT TYPE.
static BOOL IsOleVarEnumType( DBTYPE wdbType )
{
switch ( wdbType )
{
case DBTYPE_STR:
case DBTYPE_WSTR:
case DBTYPE_BYTES:
case DBTYPE_NUMERIC:
case DBTYPE_DBTIME:
case DBTYPE_DBDATE:
case DBTYPE_DBTIMESTAMP:
case DBTYPE_GUID:
case DBTYPE_VARNUMERIC:
case DBTYPE_FILETIME:
case DBTYPE_PROPVARIANT:
return FALSE;
default:
return TRUE;
}
};
// Used for creating tables where test variations have different results for different compare operators,
// on different data types, on different providers, etc.
struct VariationResults
{
WCHAR szProviderName[256];
HRESULT expHR1;
HRESULT expHR2;
int expRows;
BOOL bVerifyData;
BOOL bSQLOLEDB;
BOOL bMSDASQL;
ULONG minCompareOp;
ULONG maxCompareOp;
};
static DBLENGTH GetDataLength(void *pMakeData, DBTYPE wColType, DBLENGTH cbBytesLen)
{
DBLENGTH cbLength;
switch ( wColType )
{
case DBTYPE_WSTR:
cbLength = (wcslen((WCHAR *)pMakeData)+1)*sizeof(WCHAR);
break;
case DBTYPE_STR:
cbLength = strlen((char *)pMakeData)+sizeof(char);
break;
case DBTYPE_BYTES:
case DBTYPE_VARNUMERIC:
case DBTYPE_UDT:
cbLength = cbBytesLen;
break;
default:
cbLength = GetDBTypeSize(wColType);
break;
}
return cbLength;
}
static BOOL ValidateCompareOp ( DWORD dwFindCompareOps, DBCOMPAREOP CompareOp )
{
if ((CompareOp & DBCOMPAREOPS_CASESENSITIVE) &&
!(dwFindCompareOps & DBPROPVAL_CO_CASESENSITIVE))
return FALSE;
if ((CompareOp & DBCOMPAREOPS_CASEINSENSITIVE) &&
!(dwFindCompareOps & DBPROPVAL_CO_CASEINSENSITIVE))
return FALSE;
switch ( CompareOp & ~(DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE) )
{
case DBCOMPAREOPS_EQ:
case DBCOMPAREOPS_NE:
case DBCOMPAREOPS_LE:
case DBCOMPAREOPS_LT:
case DBCOMPAREOPS_GE:
case DBCOMPAREOPS_GT:
return ( dwFindCompareOps & DBPROPVAL_CO_EQUALITY );
case DBCOMPAREOPS_BEGINSWITH:
return ( dwFindCompareOps & DBPROPVAL_CO_STRING || dwFindCompareOps & DBPROPVAL_CO_BEGINSWITH );
case DBCOMPAREOPS_IGNORE:
return TRUE;
case DBCOMPAREOPS_NOTBEGINSWITH:
return ( dwFindCompareOps & DBPROPVAL_CO_BEGINSWITH );
case DBCOMPAREOPS_NOTCONTAINS:
case DBCOMPAREOPS_CONTAINS:
return (dwFindCompareOps & DBPROPVAL_CO_CONTAINS);
default:
return FALSE;
}
}
static DWORD GetFindCompareOps(IUnknown *pIUnknown, DBID *pColDBID)
{
IRowsetInfo * pIRowsetInfo = NULL;
DBPROPIDSET DBPropIDSet;
ULONG cPropertySets;
ULONG cProperties;
ULONG i;
DBPROPSET * prgProperties = NULL;
DWORD iFindOps = 0;
if(!VerifyInterface(pIUnknown, IID_IRowsetInfo, ROWSET_INTERFACE, (IUnknown**)&pIRowsetInfo))
return 0;
DBPropIDSet.rgPropertyIDs = NULL;
DBPropIDSet.cPropertyIDs = 1;
DBPropIDSet.guidPropertySet = DBPROPSET_ROWSET;
DBPropIDSet.rgPropertyIDs=(DBPROPID *)PROVIDER_ALLOC(sizeof(DBPROPID));
DBPropIDSet.rgPropertyIDs[0]= DBPROP_FINDCOMPAREOPS;
//get property
TESTC(SUCCEEDED(pIRowsetInfo->GetProperties(1,&DBPropIDSet, &cPropertySets, &prgProperties)));
TESTC(cPropertySets == 1);
cProperties = prgProperties[0].cProperties;
for ( i = 0; i < cProperties; i++ )
{
if ( CompareDBID(prgProperties[0].rgProperties[i].colid, DB_NULLID) )
{
iFindOps = V_I4(&prgProperties[0].rgProperties[i].vValue);
break;
}
if ( CompareDBID(*pColDBID, prgProperties[0].rgProperties[i].colid) )
iFindOps = V_I4(&prgProperties[0].rgProperties[i].vValue);
}
CLEANUP:
if(prgProperties)
{
if(prgProperties->rgProperties)
PROVIDER_FREE(prgProperties->rgProperties);
PROVIDER_FREE(prgProperties);
}
if(DBPropIDSet.rgPropertyIDs)
PROVIDER_FREE(DBPropIDSet.rgPropertyIDs);
SAFE_RELEASE(pIRowsetInfo);
return iFindOps;
}
// Some DBTYPE we can't use with this test because
// we require the values in the column to be unique.
static BOOL IsDBTYPEFindable(DBTYPE wType)
{
switch ( wType )
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_BOOL:
case DBTYPE_IDISPATCH:
case DBTYPE_IUNKNOWN:
return FALSE;
default:
return TRUE;
}
}
static BOOL AddShortToNumeric(DB_NUMERIC * pNumeric, short sNum)
{
ASSERT(pNumeric);
// Check parameters
if (!pNumeric)
return FALSE;
if (pNumeric->sign == 0)
{
sNum = -sNum; // if the numeric is negative, negate sNum
}
// If operation won't overflow
if (pNumeric->precision <= sizeof(DWORDLONG) - 1)
{
BYTE PrevSign = pNumeric->sign;
// check for sign change.
if (*(UNALIGNED DWORDLONG *)pNumeric->val < sNum)
{
if ( (sNum > 0 && PrevSign == 0) ||
(sNum < 0 && PrevSign == 1) )
{
pNumeric->sign = ( pNumeric->sign == 1 ? 0 : 1 ); // flip-flop the sign
*(UNALIGNED DWORDLONG *)pNumeric->val = MYABS(sNum) - *(UNALIGNED DWORDLONG *)pNumeric->val ;
}
}
else
*(UNALIGNED DWORDLONG *)pNumeric->val += sNum;
}
else
{
DWORDLONG dwlAccum = sNum;
// Assume 64 bit math.
for(ULONG ul = 0; ul < sizeof(pNumeric->val) / sizeof(ULONG); ul++ )
{
dwlAccum +=(DWORDLONG)(*(((UNALIGNED ULONG *)pNumeric->val) + ul));
*(((UNALIGNED ULONG *)pNumeric->val) + ul) = (ULONG)dwlAccum;
dwlAccum >>= sizeof(ULONG) * 8;
}
}
// Adjust length if overflow into next byte
if (pNumeric->precision < sizeof(pNumeric->val) &&
*(pNumeric->val + pNumeric->precision) != 0)
pNumeric->precision++;
return TRUE;
}
static BOOL AddShortToDecimal(DECIMAL * pDecimal, short sNum)
{
ASSERT(pDecimal);
// Check parameters
if (!pDecimal)
return FALSE;
// If operation won't overflow
if (pDecimal->Hi32 == 0 && pDecimal->Mid32 == 0)
{
// check for sign change.
if ( (pDecimal->sign == 0 && sNum >= 0) || (pDecimal->sign == 0x080 && sNum <= 0) )
{
pDecimal->Lo32 += MYABS(sNum);
}
else if (pDecimal->Lo32 < MYABS(sNum))
{ // possible sign change
if ( (sNum > 0 && pDecimal->sign == 0x80) ||
(sNum < 0 && pDecimal->sign == 0) )
{
pDecimal->sign = ( pDecimal->sign = 0 ? 0x80 : 0 ); // flip-flop the sign
pDecimal->Lo32 = MYABS(sNum) - pDecimal->Lo32;
}
else
pDecimal->Lo32 += MYABS(sNum);
}
else if ( (pDecimal->sign == 0 && sNum < 0) || (pDecimal->sign == 0x80 && sNum > 0) )
{
pDecimal->Lo32 -= MYABS(sNum);
}
}
else
{
DWORDLONG dwlAccum = ( pDecimal->sign == 0x80 ? -sNum : sNum );
dwlAccum += pDecimal->Lo32;
pDecimal->Lo32 = (ULONG)dwlAccum;
dwlAccum >>= sizeof(ULONG) * 8;
dwlAccum += pDecimal->Mid32;
pDecimal->Mid32 = (ULONG)dwlAccum;
dwlAccum >>= sizeof(ULONG) * 8;
dwlAccum += pDecimal->Hi32;
pDecimal->Hi32 = (ULONG)dwlAccum;
}
return TRUE;
}
void FindNullCollationProperty(IDBCreateSession *pIDBCreateSession)
{
HRESULT hr;
ULONG cProperties;
DBPROPSET * prgProperties=NULL;
DBPROPIDSET DBPropIDSet;
DBPROPID PropID = DBPROP_NULLCOLLATION;
IDBProperties * pIDBProperties = NULL;
//Initialize
DBPropIDSet.rgPropertyIDs = NULL;
DBPropIDSet.cPropertyIDs = 1;
DBPropIDSet.guidPropertySet = DBPROPSET_DATASOURCE;
DBPropIDSet.rgPropertyIDs=&PropID;
//get properties
if(!VerifyInterface(pIDBCreateSession, IID_IDBProperties, DATASOURCE_INTERFACE, (IUnknown**)&pIDBProperties))
return;
hr = pIDBProperties->GetProperties(1,&DBPropIDSet,&cProperties,&prgProperties);
if(prgProperties[0].rgProperties[cProperties-1].dwStatus==DBPROPSTATUS_NOTSUPPORTED)
{
// check for conformance violation
//ASSERT(FALSE==IsReqProperty(DBPROPSET_DATASOURCE, DBPROP_NULLCOLLATION));
g_lNullCollation = 0;
}
else
{
g_lNullCollation = V_I4(&prgProperties[0].rgProperties[0].vValue);
}
FreeProperties(&cProperties,&prgProperties);
SAFE_RELEASE(pIDBProperties);
}
static void FindVariantTypes(IUnknown *pIUnknown, CTable *pTable)
{
IAccessor * pIAccessor;
IRowset * pIRowset;
HACCESSOR hAccessor;
DBPART dwPart=DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH;
DBCOUNTITEM cBinding = 0;
DBCOUNTITEM cCount = 0;
DBCOUNTITEM i = 0;
DBLENGTH cRowSize = 0;
DBBINDING * rgBinding = NULL;
HROW * pHRow = NULL;
BYTE * pData = NULL;
VARIANT * pVar = NULL;
TESTC(VerifyInterface(pIUnknown, IID_IRowset, ROWSET_INTERFACE, (IUnknown**)&pIRowset));
TESTC(VerifyInterface(pIRowset, IID_IAccessor, ROWSET_INTERFACE, (IUnknown**)&pIAccessor));
//create an accessor on the rowset
TESTC_(GetAccessorAndBindings(pIRowset,DBACCESSOR_ROWDATA,&hAccessor,
&rgBinding,&cBinding,&cRowSize,dwPart,ALL_COLS_BOUND,FORWARD,
NO_COLS_BY_REF,NULL,NULL,NULL,DBTYPE_EMPTY,0,NULL,NULL,
NO_COLS_OWNED_BY_PROV,DBPARAMIO_NOTPARAM,TRUE), S_OK);
pData = (BYTE *)PROVIDER_ALLOC(cRowSize);
TESTC(pData != NULL);
//get the data
TESTC_(pIRowset->GetNextRows(NULL,0,1,&cCount,&pHRow), S_OK);
TESTC_(pIRowset->GetData(*pHRow, hAccessor, pData), S_OK);
for ( i = 0; i<cBinding; i++)
{
// Check for value binding
if ((rgBinding[i].dwPart) & DBPART_VALUE)
{
// Skip checking the value binding for BOOKMARKS
if (rgBinding[i].iOrdinal!=0)
{
if ( rgBinding[i].wType == DBTYPE_VARIANT )
{
// Get the data in the consumer's buffer
pVar=(VARIANT *)(pData + rgBinding[i].obValue);
CCol &NewCol = pTable->GetColInfoForUpdate(rgBinding[i].iOrdinal);
NewCol.SetSubType(pVar->vt);
}
}
}
}
CLEANUP:
if(pIRowset)
pIRowset->ReleaseRows(1,pHRow,NULL,NULL,NULL);
if(pIAccessor)
pIAccessor->ReleaseAccessor(hAccessor,NULL);
PROVIDER_FREE(rgBinding);
PROVIDER_FREE(pData);
PROVIDER_FREE(pHRow);
SAFE_RELEASE(pIAccessor);
SAFE_RELEASE(pIRowset);
return;
}
//--------------------------------------------------------------------
// @func Module level initialization routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleInit(CThisTestModule * pThisTestModule)
{
HRESULT hr;
IUnknown * pIRowset=NULL;
IRowsetInfo * pIRowsetInfo=NULL;
DBCOLUMNINFO * rgInfo=NULL;
ULONG cProperties;
DBPROPSET * prgProperties=NULL;
DBPROPIDSET DBPropIDSet;
ULONG cPropertyCount=PROPERTY_COUNT;
CCol TempCol;
SYSTEMTIME SystemTime;
BOOL fFound = FALSE, fInit = FALSE;
DBORDINAL ulStart = 0;
DATE dOleDate = 0;
WCHAR * pwszSeedValue =NULL;
if(!ModuleCreateDBSession(pThisTestModule))
return FALSE;
// When used with an .ini file, this test performs destructive variations that alter the data
// of non-updateable columns. Hence the test notifies PrivLib that read only column data
// should not be validated
if (GetModInfo())
GetModInfo()->SetCompReadOnlyCols(FALSE);
//store IDBCreateSession and IDBCreateCommand pointer
//IDBCreateSession
if(!VerifyInterface(pThisTestModule->m_pIUnknown, IID_IDBCreateSession, DATASOURCE_INTERFACE, (IUnknown**)&g_pIDBCreateSession))
return FALSE;
//IDBCreateCommand
if(!VerifyInterface(pThisTestModule->m_pIUnknown2, IID_IDBCreateCommand, SESSION_INTERFACE, (IUnknown**)&g_pIDBCreateCommand))
{
// Note the limitation and continue.
odtLog << L"IDBCreateCommand is not supported by Provider." << ENDL;
}
// Find NULL COLLATION property
FindNullCollationProperty(g_pIDBCreateSession);
//create the table
g_pCTable = new CTable(pThisTestModule->m_pIUnknown2, (WCHAR *)g_wszModuleName, USENULLS);
g_pEmptyTable = new CTable(pThisTestModule->m_pIUnknown2, (WCHAR *)g_wszModuleName, USENULLS);
g_p1RowTable = new CTable(pThisTestModule->m_pIUnknown2, (WCHAR *)g_wszModuleName, USENULLS);
if(!g_pCTable || !SUCCEEDED(g_pCTable->CreateTable(20,1,NULL,PRIMARY,TRUE))
)
{
odtLog<<L"Create Table failed, test cannot proceed\n";
return FALSE;
}
g_lRowLast = g_pCTable->GetRowsOnCTable();
if ( g_lRowLast < 8 )
{
odtLog<<L"Need at least an 8 row table for this test!\n";
return FALSE;
}
if(!g_pEmptyTable || !SUCCEEDED(g_pEmptyTable->CreateTable(0,1,NULL,PRIMARY,TRUE)))
{
odtLog<<L"Create Table failed, test cannot proceed\n";
return FALSE;
}
if ( g_pEmptyTable->GetRowsOnCTable() != 0 )
{
delete g_pEmptyTable;
g_pEmptyTable = NULL;
}
if(!g_p1RowTable || !SUCCEEDED(g_p1RowTable->CreateTable(1,1,NULL,PRIMARY,TRUE)))
{
odtLog<<L"Create Table failed, test cannot proceed\n";
return FALSE;
}
if ( g_p1RowTable->GetRowsOnCTable() != 1 )
{
delete g_p1RowTable;
g_p1RowTable = NULL;
}
//make sure IRowsetFind interface is supported by opening a rowset
//to open a rowset
hr = g_pCTable->CreateRowset( USE_OPENROWSET, IID_IRowsetFind, 0, NULL, &pIRowset,
NULL, NULL);
//if E_NOINTERFACE is returned, IRowsetFind is not supported by the provider
if(hr==ResultFromScode(E_NOINTERFACE))
{
odtLog<<L"IRowsetFind is not supported by the provider!\n";
return TEST_SKIPPED;
}
if(hr!=ResultFromScode(S_OK))
{
odtLog<<L"CTable::ExcuteCommand failed!\n";
return FALSE;
}
FindVariantTypes(pIRowset, g_pCTable);
if(GetModInfo()->GetInitStringValue(L"FINDSEED", &pwszSeedValue))
{
g_ulColNum = _wtoi(pwszSeedValue);
odtLog << "Trying to use specified seed: " << g_ulColNum << ENDL;
}
else
{
// Determine a Column seed to use for the other finds.
GetSystemTime(&SystemTime);
SystemTimeToVariantTime(&SystemTime, &dOleDate);
ulStart = ( ULONG(dOleDate) % g_pCTable->CountColumnsOnTable() ) + 1;
g_ulColNum = ulStart;
odtLog << "Using seed : " << g_ulColNum << ENDL;
}
do
{
g_pCTable->GetColInfo(g_ulColNum, TempCol);
// choose a column seed to verify correct cursor behavior
// Vary the column seed but avoid small type (I1/UI1) and
// avoid complicated types such as BLOBS and VARNUMERIC
if (ValidateCompareOp ( GetFindCompareOps(pIRowset, TempCol.GetColID()), DBCOMPAREOPS_EQ ) &&
TempCol.GetUpdateable() &&
!TempCol.GetIsLong() &&
TempCol.GetProviderType() != DBTYPE_UI1 &&
TempCol.GetProviderType() != DBTYPE_I1 &&
TempCol.GetProviderType() != DBTYPE_BOOL &&
TempCol.GetProviderType() != DBTYPE_BYTES)
{
if ( TempCol.GetProviderType() == DBTYPE_VARIANT )
{
if ( IsDBTYPEFindable(TempCol.GetSubType()) )
{
g_wColType = DBTYPE_VARIANT;
fFound = TRUE;
}
}
else if ( IsDBTYPEFindable(TempCol.GetProviderType()) )
{
g_wColType = TempCol.GetProviderType();
fFound = TRUE;
}
}
if ( !fFound )
{
if ( ++g_ulColNum > g_pCTable->CountColumnsOnTable() )
g_ulColNum = 1;
}
} while ( !fFound && ulStart != g_ulColNum );
if ( fFound )
odtLog << "Column to find value on is " << g_ulColNum << " of type " << g_wColType << ".\n";
else
{
odtLog << "No searchable columns found on target table. No testing will proceed.\n";
goto CLEANUP;
}
// IRowsetFind is supported, now retrieve information about all the properties we
// will use....
//if properites are supported
//init all the properties
//check if properites are supported
//Initialize
DBPropIDSet.rgPropertyIDs = NULL;
DBPropIDSet.cPropertyIDs = PROPERTY_COUNT;
DBPropIDSet.guidPropertySet = DBPROPSET_ROWSET;
cPropertyCount=IDX_IRowsetLocate+1;
DBPropIDSet.rgPropertyIDs=(DBPROPID *)PROVIDER_ALLOC(cPropertyCount *
sizeof(DBPROPID));
DBPropIDSet.rgPropertyIDs[IDX_Bookmarks] = DBPROP_BOOKMARKS;
DBPropIDSet.rgPropertyIDs[IDX_OrderedBookmarks] = DBPROP_ORDEREDBOOKMARKS;
DBPropIDSet.rgPropertyIDs[IDX_LiteralBookmarks] = DBPROP_LITERALBOOKMARKS;
DBPropIDSet.rgPropertyIDs[IDX_FetchBackwards] = DBPROP_CANFETCHBACKWARDS;
DBPropIDSet.rgPropertyIDs[IDX_ScrollBackwards] = DBPROP_CANSCROLLBACKWARDS;
DBPropIDSet.rgPropertyIDs[IDX_CanHoldRows] = DBPROP_CANHOLDROWS;
DBPropIDSet.rgPropertyIDs[IDX_RemoveDeleted] = DBPROP_REMOVEDELETED;
DBPropIDSet.rgPropertyIDs[IDX_BookmarkSkipped] = DBPROP_BOOKMARKSKIPPED;
DBPropIDSet.rgPropertyIDs[IDX_OtherUpdateDelete] = DBPROP_OTHERUPDATEDELETE;
DBPropIDSet.rgPropertyIDs[IDX_OtherInsert] = DBPROP_OTHERINSERT;
DBPropIDSet.rgPropertyIDs[IDX_IRowsetDeleteBookmarks] = DBPROP_IRowsetChange;
DBPropIDSet.rgPropertyIDs[IDX_BookmarkType] = DBPROP_BOOKMARKTYPE;
DBPropIDSet.rgPropertyIDs[IDX_IRowsetChange] = DBPROP_IRowsetChange;
DBPropIDSet.rgPropertyIDs[IDX_IRowsetLocate] = DBPROP_IRowsetLocate;
//Get Rowset Info
if(!VerifyInterface(pIRowset, IID_IRowsetInfo, ROWSET_INTERFACE, (IUnknown**)&pIRowsetInfo))
goto CLEANUP;
//mark everything as supported
for(cProperties=0;cProperties<PROPERTY_COUNT;cProperties++)
{
g_rgDBPrpt[cProperties].fSupported=TRUE;
g_rgDBPrpt[cProperties].fDefault=FALSE;
}
//get properties
if(!SUCCEEDED(hr=pIRowsetInfo->GetProperties(1,&DBPropIDSet, &cProperties, &prgProperties)))
goto CLEANUP;
//mark the properties
for(cProperties=0;cProperties<PROPERTY_COUNT;cProperties++)
{
//mark the not supported properties
if(prgProperties[0].rgProperties[cProperties].dwStatus==DBPROPSTATUS_NOTSUPPORTED)
{
// check for conformance violation
//ASSERT(FALSE==IsReqProperty(DBPropIDSet.rgPropertyIDs[cProperties], DBPropIDSet.guidPropertySet));
g_rgDBPrpt[cProperties].fSupported=FALSE;
g_rgDBPrpt[cProperties].fDefault=FALSE;
}
else
{
if(prgProperties[0].rgProperties[cProperties].dwStatus!=DBPROPSTATUS_OK)
odtLog<<L"Error: default value failed for properties indexed at "<<cProperties<<L".\n";
//mark as supported properties
g_rgDBPrpt[cProperties].fSupported=TRUE;
if(cProperties==IDX_BookmarkType)
{
if(prgProperties[0].rgProperties[cProperties].vValue.lVal
!=DBPROPVAL_BMK_NUMERIC)
{
odtLog<<L"ERROR: The bookmark is not based on numeric!\n";
if(prgProperties[0].rgProperties[cProperties].vValue.lVal
!=DBPROPVAL_BMK_KEY)
odtLog<<L"ERROR: The bookmark type returned false information!\n";
}
}
else
{
g_rgDBPrpt[cProperties].fDefault=
V_BOOL(&prgProperties[0].rgProperties[cProperties].vValue);
}
}
}
fInit = TRUE;
CLEANUP:
//release rowset objects
SAFE_RELEASE(pIRowsetInfo);
SAFE_RELEASE(pIRowset);
PROVIDER_FREE(pwszSeedValue);
//free the memory
if(prgProperties)
{
if(prgProperties->rgProperties)
PROVIDER_FREE(prgProperties->rgProperties);
PROVIDER_FREE(prgProperties);
}
if(DBPropIDSet.rgPropertyIDs)
PROVIDER_FREE(DBPropIDSet.rgPropertyIDs);
return fInit;
}
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
//drop tables
if(g_pCTable)
{
g_pCTable->DropTable();
delete g_pCTable;
g_pCTable = NULL;
}
if(g_p1RowTable)
{
g_p1RowTable->DropTable();
delete g_p1RowTable;
g_p1RowTable = NULL;
}
if(g_pEmptyTable)
{
g_pEmptyTable->DropTable();
delete g_pEmptyTable;
g_pEmptyTable = NULL;
}
SAFE_RELEASE(g_pIDBCreateSession);
SAFE_RELEASE(g_pIDBCreateCommand);
SAFE_RELEASE(g_pIDataConvert);
return (ModuleReleaseDBSession(pThisTestModule));
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Base Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// TCIRowsetFind: the base class for the rest of test cases in this
// test module.
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class TCIRowsetFind : public CRowsetObject
{
private:
protected:
//@cmember: interface pointer for IRowsetFind
IRowsetFind * m_pIRowsetFind;
//@cmember: interface pointer for IRowset
IRowset * m_pIRowset;
//@cmember: interface pointer for IConvertType
IConvertType * m_pIConvertType;
//@cmember: accessory handle
HACCESSOR m_hAccessor;
//@cmember: accessory handle that will only be used as argument to IRowsetFind
HACCESSOR m_hRowsetFindAccessor;
//@cmember: the size of a row
DBLENGTH m_cRowSize;
//@cmember: the count of binding structure
DBCOUNTITEM m_cBinding;
//@cmember: the array of binding strucuture
DBBINDING * m_rgBinding;
//@cmember: the pointer to the row buffer
void * m_pData;
//@cmember: the pointer to the pFindValue buffer
BYTE * m_pFindValue;
//@cmember: wherther Privlib FillInputBindings was used to fill m_pFindValue
BOOL m_fUsePrivlibFillInputBindings;
//@cmember: the pointers Bindings arrays
DBCOUNTITEM m_cFindBindings;
DBBINDING * m_rgFindBindings;
HROW * m_rghRowsFound;
DBCOUNTITEM m_cRowsFound;
//@cmember: the pointer to the ISequentialStream interface
ISequentialStream * m_pISeqStream;
//@mfunc: initialialize interface pointers
BOOL Init();
//@mfunc: Terminate
BOOL Terminate();
//@mfunc: Create a command object and set properties, execute a sql statement,
// and create a rowset object. Create an accessor on the rowset
BOOL GetRowsetAndAccessor
(
CTable *pCTable,
EQUERY eSQLStmt,
IID riid,
ULONG cProperties=0,
const DBPROPID *rgProperties=NULL,
DBACCESSORFLAGS dwAccessorFlags=DBACCESSOR_ROWDATA,
DBPART dwPart=DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ECOLS_BOUND eColsToBind=ALL_COLS_BOUND,
ECOLUMNORDER eBindingOrder=FORWARD,
ECOLS_BY_REF eColsByRef=NO_COLS_BY_REF,
WCHAR *pwszTableName=NULL,
EEXECUTE eExecute=EXECUTE_IFNOERROR,
DBTYPE dbTypeModifier=DBTYPE_EMPTY,
BOOL fBindLongColumns=FALSE
);
//@mfun: create an accessor on the rowset.
BOOL GetAccessorOnRowset
(
DBACCESSORFLAGS dwAccessorFlags=DBACCESSOR_ROWDATA,
DBPART dwPart=DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ECOLS_BOUND eColsToBind=ALL_COLS_BOUND,
ECOLUMNORDER eBindingOrder=FORWARD,
ECOLS_BY_REF eColsByRef=NO_COLS_BY_REF,
DBTYPE dbTypeModifier=DBTYPE_EMPTY,
BOOL fBindLongColumns=TRUE
);
//@mfun: Get the bookmark for the row
BOOL GetBookmark
(
DBCOUNTITEM ulRow,
ULONG_PTR * pcbBookmark,
BYTE ** ppBookmark
);
BOOL BookmarkSkipped();
BOOL RemoveDeleted();
BOOL GetProp
(
DBPROPID DBPropID
);
//@mfunc: release the memory referenced by the consumer's buffer
void FreeMemory
(
CTable * pCTable=g_pCTable
);
//@mfunc: release a rowset object and accessor created on it
BOOL ReleaseRowsetAndAccessor();
//@mfunc: release a accessor created on it
BOOL ReleaseAccessorOnRowset();
//mfunc: populate the table after delete some rows
BOOL PopulateTable();
//@mfunc: verify the position of the row handle in the row set
BOOL VerifyRowPosition
(
HROW hRow, //row handle
DBCOUNTITEM cRow, //potision expected
CTable * pCTable, //pointer to the CTable
EVALUE eValue=PRIMARY //eValue for MakeData
);
//@mfunc: verify the position of the cursor in the row set
BOOL VerifyCursorPosition
(
DBCOUNTITEM cRow, //the cursor potision expected
CTable * pCTable, //pointer to the CTable
BOOL fMoveBack=FALSE,//whether move the cursor back to its original postion
//if fMoveBack==FALSE; the cursor will be positioned one row
//after the original position. If fMoveBack==TRUE,
//DBPROP_CANSCROLLBACKWARDS needs to be set.
EVALUE eValue=PRIMARY //eValue for MakeData
);
BOOL CreateCoerceFindValueAccessor
(
DBCOMPAREOP CompareOp,
CTable * pCTable,
DBCOUNTITEM ulRowNum,
DBCOUNTITEM ulColToFind,
DBTYPE wBindType
);
BOOL CreateFindValueAccessor
(
DBCOMPAREOP CompareOp,
CTable * pCTable,
DBCOUNTITEM ulRowNum,
DBORDINAL ulColNum,
DBTYPE wColType,
eSUBCOMPAREOP eSubCompare,
BOOL fUseStream = FALSE,
DBCOMPAREOP * pwNewCompareOp = NULL,
DBPART dbPart = DBPART_INVALID,
HRESULT * phrExpected = NULL
);
BOOL ReleaseFindValueAccessor
(
DBTYPE wColType
);
BOOL CallFindNextRows
(
CTable * pCTable, // pointer to CTable object
BYTE * pBookmark, // Bookmark to fetch from, if any
ULONG_PTR cbBookmark, // Length of bookmark.
DBROWCOUNT lRowsToFetch, // maps to cRows
DBROWOFFSET lOffset, // maps to lOffset
DBORDINAL ulColToMatch, // Which column to match
DBCOUNTITEM ulRowToMatch, // Is there a row where the find should happen? 0 - no match
HRESULT hrExpAccessor, // Expected HRESULT for Create Accessor Step
DBCOUNTITEM ulRowsExpected, // Expected count of rows
BOOL fReleaseRows=TRUE, // Flag to Release Rows.
DBCOMPAREOP CompareOp=DBCOMPAREOPS_EQ, // Any particular preference for comparing?
eSUBCOMPAREOP eSubCompare=SUBOP_EMPTY, // Some comparision are rich enough to deserve a sub comparision
HROW * rghRows = NULL, // Use client or provider memory, default=provider
BOOL fCheckRows = TRUE, // verify rows by comparing data ?
BOOL fUseStream = FALSE, // Use ISeqStream ?
HRESULT hrExpFind = -1 // Second expected HRESULT for the FindNextRow step
);
BOOL AlterData
(
BYTE ** ppMakeData,
DBCOMPAREOP CompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength,
eSUBCOMPAREOP eSubCompare
);
BOOL AlterNumericData
(
BYTE ** ppMakeData,
DBCOMPAREOP CompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength
);
BOOL AlterCharacterData
(
void ** ppMakeData,
DBCOMPAREOP CompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength,
eSUBCOMPAREOP eSubCompare
);
BOOL AlterVarnumericData
(
BYTE ** ppMakeData,
DBCOMPAREOP CompareOp,
DBLENGTH * pcbDataLength
);
BOOL BindingTypeTest
(
CTable * pCTable,
DBTYPE wBindingType
);
BOOL CompareOpTest
(
CTable * pCTable,
DBCOMPAREOP CompareOp,
eSUBCOMPAREOP eSubCompare,
BOOL fUseStream=FALSE
);
BOOL DeleteRow
(
CTable * pCTable,
DBCOUNTITEM ulRowToDelete
);
DWORD TC_FindCompareOps
(
DBID * pColDBID
);
BOOL AlteringRowsIsOK();
BOOL IsColumnMinimumFindable
(
CCol * pCol,
DBCOMPAREOP CompareOp
);
BOOL IsTypeFindable
(
DBTYPE wType,
DBCOMPAREOP CompareOp,
DBTYPE wSubType = DBTYPE_EMPTY
);
BOOL IsStringType
(
DBTYPE wType
);
BOOL IsStringCompareOp
(
DBCOMPAREOP CompareOp
);
BOOL IsColumnFindable
(
CCol * pCol,
DBCOMPAREOP CompareOp
);
HRESULT RestartRowPosition();
BOOL GetVariableLengthStrAndUpdatable
(
DBORDINAL * pulColNum,
DBCOMPAREOP CompareOp,
BOOL fGetLongStr = FALSE,
DBTYPE * pwType = NULL
);
BOOL GetNonNullableCol
(
DBORDINAL * pulColNum,
DBCOMPAREOP CompareOp,
BOOL fGetLongStr,
DBTYPE * pwType
);
public:
//constructor and destructor
TCIRowsetFind(WCHAR *wstrTestCaseName);
~TCIRowsetFind();
};
//--------------------------------------------------------------------
// @mfunc base class TCIRowsetFind constructor, must take testcase name
// as parameter.
//
TCIRowsetFind::TCIRowsetFind
(
WCHAR * wstrTestCaseName //Takes TestCase Class name as parameter
) : CRowsetObject (wstrTestCaseName)
{
//initialize member data
m_pIRowsetFind = NULL;
m_pIRowset = NULL;
m_pIConvertType = NULL;
m_pFindValue = NULL;
m_pIAccessor = NULL;
m_pISeqStream = NULL;
m_hAccessor = NULL;
m_hRowsetFindAccessor = NULL;
m_cRowSize = 0;
m_cBinding = 0;
m_rgBinding = NULL;
m_pData = NULL;
m_hr = S_OK;
m_cFindBindings =0;
m_rgFindBindings = NULL;
m_cRowsFound = 0;
m_rghRowsFound = NULL;
}
//--------------------------------------------------------------------
// @mfunc base class TCIRowsetFind destructor
//
TCIRowsetFind::~TCIRowsetFind()
{
}
//--------------------------------------------------------------------
//@mfunc: Init creates a Data Source object, a DB Session object,
//and a command object and initialize corresponding interface pointers.
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::Init()
{
return (COLEDB::Init());
}
//--------------------------------------------------------------------
//@mfunc: Terminate release the data source object, DB Session object, Command object
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::Terminate()
{
return (COLEDB::Terminate());
}
//--------------------------------------------------------------------
//@mfunc: Create a command object and set properties, execute a sql statement,
// and create a rowset object. Create an accessor on the rowset
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::GetRowsetAndAccessor
(
CTable * pCTable, //the pointer to the table object
EQUERY eSQLStmt, //the SQL Statement to create
IID riid, //the interface pointer to return
ULONG cProperties, //the count of properties
const DBPROPID * rgProperties, //the array of properties to be set
DBACCESSORFLAGS dwAccessorFlags, //the accessor flags
DBPART dwPart, //the type of binding
ECOLS_BOUND eColsToBind, //the columns in accessor
ECOLUMNORDER eBindingOrder, //the order to bind columns
ECOLS_BY_REF eColsByRef, //which columns to bind by reference
WCHAR * pwszTableName, //the table name for the join statement
EEXECUTE eExecute, //execute only if all properties are set
DBTYPE dbTypeModifier, //the type modifier used for accessor
BOOL fBindLongColumns //whether to long columns
)
{
HRESULT hr;
ULONG cProp = 0, i = 0;
DBPROPSET rgPropSets[1];
BOOL bReturn = FALSE;
BLOBTYPE blobType;
BOOL bIsOrderedBookMarkProperty = FALSE;
//init rgPropSets[0]
rgPropSets[0].rgProperties = NULL;
rgPropSets[0].cProperties = cProperties;
rgPropSets[0].guidPropertySet= DBPROPSET_ROWSET;
rgPropSets[0].rgProperties=(DBPROP *)PROVIDER_ALLOC
(sizeof(DBPROP) * (cProperties + 1));
memset(rgPropSets[0].rgProperties, 0, sizeof(DBPROP) * (cProperties + 1));
TESTC(rgPropSets[0].rgProperties != NULL);
//go through the loop to set every DB Property required
for(i=0; i<cProperties; i++)
{
VariantInit(&(rgPropSets[0].rgProperties[cProp].vValue));
//Set KAGPROP_QUERYBASEDUPDATES if need be
switch(rgProperties[i])
{
case DBPROP_UPDATABILITY:
rgPropSets[0].rgProperties[cProp].dwPropertyID=DBPROP_UPDATABILITY;
rgPropSets[0].rgProperties[cProp].dwOptions=DBPROPOPTIONS_REQUIRED;
rgPropSets[0].rgProperties[cProp].vValue.vt=VT_I4;
rgPropSets[0].rgProperties[cProp].vValue.lVal=
DBPROPVAL_UP_CHANGE|DBPROPVAL_UP_DELETE|DBPROPVAL_UP_INSERT;
cProp++;
break;
case DBPROP_IRowsetLocate:
fBindLongColumns = BLOB_LONG;
// intentional fallthru
default:
if (rgProperties[i]== DBPROP_ORDEREDBOOKMARKS)
{
bIsOrderedBookMarkProperty = TRUE;
}
rgPropSets[0].rgProperties[cProp].dwPropertyID = rgProperties[i];
rgPropSets[0].rgProperties[cProp].dwOptions = DBPROPOPTIONS_REQUIRED;
rgPropSets[0].rgProperties[cProp].vValue.vt = VT_BOOL;
V_BOOL(&rgPropSets[0].rgProperties[cProp].vValue)= VARIANT_TRUE;
cProp++;
break;
}
}
//Set properties and execute the SQL statement
//May fail due to combinations of properties
ASSERT(SUCCEEDED(SetRowsetProperties(rgPropSets, 1)));
if(fBindLongColumns)
blobType=BLOB_LONG;
else
blobType=NO_BLOB_COLS;
//Set CTable object
SetTable(pCTable, DELETETABLE_NO);
hr = CreateRowsetObject(eSQLStmt, riid, EXECUTE_IFNOERROR);
if(hr==DB_S_ERRORSOCCURRED || hr==DB_E_ERRORSOCCURRED)
goto CLEANUP;
TESTC_(hr,S_OK);
//queryinterface for IRowsetFind, IRowset, and IConvertType
TESTC(VerifyInterface(m_pIAccessor, IID_IRowset, ROWSET_INTERFACE,
(IUnknown **)&m_pIRowset));
TESTC(VerifyInterface(m_pIRowset, IID_IRowsetFind, ROWSET_INTERFACE,
(IUnknown **)&m_pIRowsetFind));
TESTC(VerifyInterface(m_pIRowset, IID_IConvertType, ROWSET_INTERFACE,
(IUnknown **)&m_pIConvertType));
//if dwAccessorFlags=DBACCESSOR_PASSBYREF, no need to create an accessor
if(dwAccessorFlags == DBACCESSOR_PASSBYREF)
{
bReturn = TRUE;
goto CLEANUP;
}
//create an accessor on the rowset
TESTC_(GetAccessorAndBindings(m_pIRowset,dwAccessorFlags,&m_hAccessor,
&m_rgBinding,&m_cBinding,&m_cRowSize,dwPart,eColsToBind,eBindingOrder,
eColsByRef,NULL,NULL,NULL,dbTypeModifier,0,NULL,NULL,
NO_COLS_OWNED_BY_PROV,DBPARAMIO_NOTPARAM,blobType),S_OK);
//allocate memory for the row
m_pData = PROVIDER_ALLOC(m_cRowSize);
if(m_pData)
bReturn = TRUE;
CLEANUP:
//free the memory
PROVIDER_FREE(rgPropSets[0].rgProperties);
return bReturn;
}
BOOL TCIRowsetFind::GetAccessorOnRowset
(
DBACCESSORFLAGS dwAccessorFlags,
DBPART dwPart,
ECOLS_BOUND eColsToBind,
ECOLUMNORDER eBindingOrder,
ECOLS_BY_REF eColsByRef,
DBTYPE dbTypeModifier,
BOOL fBindLongColumns
)
{
BLOBTYPE blobType;
if(fBindLongColumns)
blobType=BLOB_LONG;
else
blobType=NO_BLOB_COLS;
//create an accessor on the rowset
if(!CHECK(GetAccessorAndBindings(m_pIRowset,dwAccessorFlags,&m_hAccessor,
&m_rgBinding,&m_cBinding,&m_cRowSize,dwPart,eColsToBind,eBindingOrder,
eColsByRef,NULL,NULL,NULL,dbTypeModifier,blobType),S_OK))
return FALSE;
//allocate memory for the row
m_pData=PROVIDER_ALLOC(m_cRowSize);
if(!m_pData)
return FALSE;
return TRUE;
}
//--------------------------------------------------------------------
//@mfun: Get the bookmark for the row. The function has to be called
// after the GetRowsetAndAccessor that creates an accessor on the
// rowset.
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::GetBookmark
(
DBCOUNTITEM ulRow,
ULONG_PTR * pcbBookmark,
BYTE ** ppBookmark
)
{
BOOL fPass=FALSE;
HROW * pHRow=NULL;
DBCOUNTITEM cCount;
//ulRow has to start with 1
if(!pcbBookmark || !ppBookmark || !ulRow)
return FALSE;
//restart the cursor position
if(!CHECK(m_pIRowset->RestartPosition(NULL),S_OK))
return FALSE;
//fetch the row
TESTC_(m_pIRowset->GetNextRows(NULL,(ulRow-1),1,&cCount,&pHRow),S_OK);
//only one row handle is retrieved
COMPARE(cCount, 1);
//get the data
TESTC_(m_pIRowset->GetData(*pHRow, m_hAccessor, m_pData),S_OK);
//make sure the 0 column is for bookmark
if(!COMPARE(m_rgBinding[0].iOrdinal, 0))
{
FreeMemory();
goto CLEANUP;
}
//get the length of the bookmark
*pcbBookmark= *((DBLENGTH *)((BYTE *)m_pData+m_rgBinding[0].obLength));
//allocate memory for bookmark
*ppBookmark=(BYTE *)PROVIDER_ALLOC(*pcbBookmark);
TESTC(*ppBookmark != NULL);
//copy the value of the bookmark into the consumer's buffer
memcpy(*ppBookmark, (void *)((BYTE *)m_pData+m_rgBinding[0].obValue), *pcbBookmark);
//free the memory referenced by the consumer's buffer
FreeMemory();
fPass=TRUE;
CLEANUP:
if(pHRow)
{
CHECK(m_pIRowset->ReleaseRows(1,pHRow,NULL,NULL,NULL),S_OK);
PROVIDER_FREE(pHRow);
}
//restart the cursor position
if(!CHECK(m_pIRowset->RestartPosition(NULL),S_OK))
return FALSE;
return fPass;
}
//--------------------------------------------------------------
//
// Get information about properties
//
//-----------------------------------------------------------------
BOOL TCIRowsetFind::GetProp(DBPROPID DBPropID)
{
IRowsetInfo * pIRowsetInfo=NULL;
ULONG cProperty;
DBPROPIDSET DBPropIDSet;
DBPROPSET * pDBPropSet=NULL;
BOOL fSupported=FALSE;
//initialize
DBPropIDSet.guidPropertySet = DBPROPSET_ROWSET;
DBPropIDSet.cPropertyIDs = 1;
DBPropIDSet.rgPropertyIDs = &DBPropID;
//QI for IRowsetInfo interface
TESTC_(m_pIRowset->QueryInterface(IID_IRowsetInfo,(LPVOID *)&pIRowsetInfo),S_OK);
TESTC(SUCCEEDED(pIRowsetInfo->GetProperties(1,&DBPropIDSet,&cProperty,&pDBPropSet)));
if(V_BOOL(&pDBPropSet->rgProperties->vValue) == VARIANT_TRUE)
fSupported=TRUE;
CLEANUP:
for(ULONG i=0;i<cProperty;i++)
PRVTRACE(L"[%d] status == %d \n",pDBPropSet[0].rgProperties[i].dwPropertyID,pDBPropSet[0].rgProperties[i].dwStatus);
if(pDBPropSet)
{
if(pDBPropSet->rgProperties)
PROVIDER_FREE(pDBPropSet->rgProperties);
PROVIDER_FREE(pDBPropSet);
}
SAFE_RELEASE(pIRowsetInfo);
return fSupported;
}
//--------------------------------------------------------------------
//@mfunc: If BookmarkSkipped is supported on the rowset
//--------------------------------------------------------------------
BOOL TCIRowsetFind::BookmarkSkipped()
{
IRowsetInfo * pIRowsetInfo=NULL;
ULONG cProperty;
DBPROPID DBPropID=DBPROP_BOOKMARKSKIPPED;
DBPROPIDSET DBPropIDSet;
DBPROPSET * pDBPropSet=NULL;
BOOL fSupported=FALSE;
if(!g_rgDBPrpt[IDX_BookmarkSkipped].fSupported)
return FALSE;
//initialize
DBPropIDSet.guidPropertySet = DBPROPSET_ROWSET;
DBPropIDSet.cPropertyIDs = 1;
DBPropIDSet.rgPropertyIDs = &DBPropID;
//QI for IRowsetInfo interface
TESTC_(m_pIRowset->QueryInterface(IID_IRowsetInfo,(LPVOID *)&pIRowsetInfo),S_OK);
//ask for DBPROP_BOOKMARKSKIPPED
TESTC_(pIRowsetInfo->GetProperties(1,&DBPropIDSet,&cProperty,
&pDBPropSet),S_OK);
if(V_BOOL(&pDBPropSet->rgProperties->vValue)==VARIANT_TRUE)
fSupported=TRUE;
CLEANUP:
if(pDBPropSet)
{
if(pDBPropSet->rgProperties)
PROVIDER_FREE(pDBPropSet->rgProperties);
PROVIDER_FREE(pDBPropSet);
}
SAFE_RELEASE(pIRowsetInfo);
return fSupported;
}
//--------------------------------------------------------------------
// Populate the table after some rows are deleted
//--------------------------------------------------------------------
BOOL TCIRowsetFind::PopulateTable()
{
long cCnt;
//delete all rows in the table.
if(!CHECK(g_pCTable->DeleteRows(ALLROWS),S_OK))
return FALSE;
// freshly populate
for(cCnt=1; cCnt<=g_lRowLast; cCnt++)
if(!CHECK(g_pCTable->Insert(cCnt, PRIMARY),S_OK))
return FALSE;
return TRUE;
}
//--------------------------------------------------------------------
//@mfunc: If RemoveDeleted is supported on the rowset
//--------------------------------------------------------------------
BOOL TCIRowsetFind::RemoveDeleted()
{
IRowsetInfo * pIRowsetInfo=NULL;
ULONG cProperty;
DBPROPID DBPropID=DBPROP_REMOVEDELETED;
DBPROPIDSET DBPropIDSet;
DBPROPSET * pDBPropSet=NULL;
BOOL fSupported=FALSE;
if(!g_rgDBPrpt[IDX_RemoveDeleted].fSupported)
return FALSE;
//initialize
DBPropIDSet.guidPropertySet = DBPROPSET_ROWSET;
DBPropIDSet.cPropertyIDs = 1;
DBPropIDSet.rgPropertyIDs = &DBPropID;
//QI for IRowsetInfo interface
TESTC_(m_pIRowset->QueryInterface(IID_IRowsetInfo,(LPVOID *)&pIRowsetInfo),S_OK);
//ask for DBPROP_BOOKMARKSKIPPED
TESTC_(pIRowsetInfo->GetProperties(1,&DBPropIDSet,&cProperty,
&pDBPropSet),S_OK);
if(V_BOOL(&pDBPropSet->rgProperties->vValue)==VARIANT_TRUE)
fSupported=TRUE;
CLEANUP:
if(pDBPropSet)
{
if(pDBPropSet->rgProperties)
PROVIDER_FREE(pDBPropSet->rgProperties);
PROVIDER_FREE(pDBPropSet);
}
SAFE_RELEASE(pIRowsetInfo);
return fSupported;
}
//--------------------------------------------------------------------
//@mfunc: free the memory referenced by the consumer's buffer
// The function has to be called after IRowset::GetData()
//
//--------------------------------------------------------------------
void TCIRowsetFind::FreeMemory(CTable *pCTable)
{
//make sure m_pData is not NULL
if(!COMPARE(!m_pData, NULL))
return;
//make sure the columns are bound
if(!m_rgTableColOrds)
return;
//call compareData with the option to free the memory referenced by the consumer's
//buffer without comparing data
CompareData(m_cRowsetCols,m_rgTableColOrds,1,m_pData,m_cBinding,m_rgBinding,pCTable,
NULL,PRIMARY,FREE_ONLY);
}
//--------------------------------------------------------------------
//@mfunc: release a rowset object and accessor created on it
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::ReleaseRowsetAndAccessor()
{
BOOL fPass = TRUE;
//free the consumer buffer
PROVIDER_FREE(m_pData);
PROVIDER_FREE(m_rgBinding);
PROVIDER_FREE(m_rgTableColOrds);
//free accessor handle
if(m_hAccessor)
{
if(!CHECK(m_pIAccessor->ReleaseAccessor(m_hAccessor,NULL), S_OK))
fPass=FALSE;
m_hAccessor=NULL;
}
SAFE_RELEASE(m_pIRowset);
SAFE_RELEASE(m_pIRowsetFind);
SAFE_RELEASE(m_pIConvertType);
ReleaseRowsetObject(); //releases m_pIAccessor
ReleaseCommandObject(); //releases m_pICommand
ReleaseDBSession();
ReleaseDataSourceObject();
return fPass;
}
BOOL TCIRowsetFind::ReleaseAccessorOnRowset()
{
BOOL fPass=TRUE;
//free the consumer buffer
PROVIDER_FREE(m_pData);
PROVIDER_FREE(m_rgBinding);
//free accessor handle
if(m_hAccessor)
{
if(!CHECK(m_pIAccessor->ReleaseAccessor(m_hAccessor,NULL), S_OK))
fPass=FALSE;
m_hAccessor=NULL;
}
return fPass;
}
//--------------------------------------------------------------------
//
//@mfunc: verify the position of the row handle in the row set
//
// Precondition: The function has to be called after GetRowsetAndAccessor that
// creates a rowset and an accessor
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::VerifyRowPosition
(
HROW hRow, //row handle
DBCOUNTITEM cRow, //position expected
CTable * pCTable, //pointer to the CTable
EVALUE eValue //if the accessor is ReadColumnsByRef
)
{
//input validation
if(!pCTable || !m_pIRowset || !m_pData)
return FALSE;
//Get Data for the row
if(!CHECK(m_pIRowset->GetData(hRow,m_hAccessor,m_pData),S_OK))
return FALSE;
//compare the data with the row expected in the rowset
if(!CompareData(m_cRowsetCols,m_rgTableColOrds,cRow,m_pData,m_cBinding,m_rgBinding,pCTable,
NULL,eValue))
return FALSE;
return TRUE;
}
//--------------------------------------------------------------------
//
//@mfunc: verify the position of the cursor in the row set
//
// Precondition: The function has to be called after GetRowsetAndAccessor that
// creates a rowset and an accessor.
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::VerifyCursorPosition
(
DBCOUNTITEM cRow, //the cursor potision expected
CTable * pCTable, //pointer to the CTable
BOOL fMoveBack, //whether move the cursor back to its original postion
//if fMoveBack==FALSE; the cursor will be positioned one row
//after the original position. If fMoveBack==TRUE,
//DBPROP_CANSCROLLBACKWARDS needs to be set.
EVALUE eValue //eValue for MakeData
)
{
HROW hRow[1];
HROW * pHRow = hRow;
DBCOUNTITEM cRows;
BOOL fTestPass=TRUE;
//input validation
if(!pCTable || !m_pIRowset || !m_pData)
return FALSE;
//Get a row handle
if(!CHECK(m_pIRowset->GetNextRows(NULL,0,1,&cRows,&pHRow),S_OK))
return FALSE;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(hRow[0],cRow,pCTable,eValue),TRUE))
fTestPass=FALSE;
//release the row handle
CHECK(m_pIRowset->ReleaseRows(1,hRow,NULL,NULL,NULL),S_OK);
//reposition the cursor to its original position
if(fMoveBack)
{
if(!CHECK(m_pIRowset->GetNextRows(NULL,-1,0,&cRows,&pHRow),S_OK))
fTestPass=FALSE;
}
return (fTestPass);
}
//--------------------------------------------------------------------
//
//@mfunc: Create Accessor for the pFindValue argument to IRowsetFind::FindNextRows
// Bind to a type other than the native type to test coercion
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::CreateCoerceFindValueAccessor
(
DBCOMPAREOP CompareOp,
CTable * pCTable,
DBCOUNTITEM ulRowNum,
DBORDINAL ulColToFind,
DBTYPE wBindType
)
{
BOOL fChanged = FALSE;
BOOL fRet = FALSE;
WCHAR wszData[2000];
CCol TempCol;
USHORT ulsize;
DBLENGTH cbDataLength = 0;
BYTE * pMakeData;
DBTYPE wVariantType = DBTYPE_EMPTY, wColType, wByRefType = DBTYPE_EMPTY;
HRESULT hr;
pCTable->GetColInfo(ulColToFind, TempCol);
wColType = TempCol.GetProviderType();
wByRefType = wBindType & DBTYPE_BYREF;
wBindType &= (~DBTYPE_BYREF);
// This only has support for these major types
if ( wBindType != DBTYPE_WSTR && wBindType != DBTYPE_STR && wBindType != DBTYPE_BSTR && wBindType != DBTYPE_VARIANT )
return FALSE;
// Only supports EQ; may add more support
if ( CompareOp != DBCOMPAREOPS_EQ )
return FALSE;
if ( !IsColumnMinimumFindable(&TempCol, CompareOp) )
return FALSE;
if ( ulRowNum == 0 )
{
// create data that won't match by creating data for a row that doesn't exist yet.
ulRowNum = pCTable->GetNextRowNumber();
}
if (!SUCCEEDED(hr = pCTable->MakeData( wszData,
ulRowNum,
ulColToFind,
PRIMARY,
( wColType == DBTYPE_VARIANT && ulRowNum > ULONG(g_lRowLast) ? DBTYPE_BSTR : wColType ),
FALSE,
&wVariantType)) )
goto CLEANUP;
if ( ulRowNum > ULONG(g_lRowLast) )
wVariantType = DBTYPE_BSTR;
if ( hr == S_OK && wVariantType != DBTYPE_NULL )
{
if ( CompareOp & DBCOMPAREOPS_CASEINSENSITIVE )
{
// Change first char to lowercase.
char szAnsi[3], szDest[3];
WCHAR wszDest[2];
DWORD cbWritten;
cbWritten = WideCharToMultiByte(CP_ACP, 0, wszData, 1, szAnsi, 3, NULL, NULL);
szAnsi[cbWritten] = '\0';
LCMapStringA(GetUserDefaultLCID(),LCMAP_LOWERCASE,szAnsi,-1,szDest,3);
cbWritten = MultiByteToWideChar(CP_ACP, 0, szDest, -1, wszDest, 2);
wszData[0] = wszDest[0];
}
if ( wBindType == DBTYPE_VARIANT )
{
BSTR bstr = SysAllocString(wszData);
pMakeData = (BYTE *)DBTYPE2VARIANT(&bstr, VT_BSTR);
SysFreeString(bstr);
}
else
{
pMakeData = (BYTE *)WSTR2DBTYPE(wszData, wBindType , &ulsize);
}
cbDataLength = GetDataLength(pMakeData, wBindType, ulsize);
m_pFindValue = (BYTE *)PROVIDER_ALLOC(cbDataLength+sizeof(FindValueInfo));
// Set up our m_pFindValue struct to match offsets we give to our Binding.
switch ( wBindType | wByRefType )
{
case DBTYPE_BSTR | DBTYPE_BYREF:
case DBTYPE_STR | DBTYPE_BYREF:
case DBTYPE_WSTR | DBTYPE_BYREF:
case DBTYPE_VARIANT | DBTYPE_BYREF:
memcpy(m_pFindValue+offsetof(FindValueInfo, pValue), &pMakeData, cbDataLength);
break;
default:
memcpy(m_pFindValue+offsetof(FindValueInfo, pValue), pMakeData, cbDataLength);
}
}
if ( hr == S_FALSE || wVariantType == DBTYPE_NULL)
{
m_pFindValue = (BYTE *)PROVIDER_ALLOC(sizeof(DBSTATUS)+2*sizeof(DBLENGTH));
*(DBSTATUS *)(m_pFindValue+offsetof(FindValueInfo, dbsStatus)) = DBSTATUS_S_ISNULL;
// bogus length shouldn't matter since NULL status was set
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = MAXDBCOUNTITEM;
}
else
{
*(DBSTATUS *)(m_pFindValue+offsetof(FindValueInfo, dbsStatus)) = DBSTATUS_S_OK;
switch ( wBindType )
{
case DBTYPE_WSTR:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength-sizeof(WCHAR);
break;
case DBTYPE_STR:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength-sizeof(char);
break;
default:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength;
break;
}
}
// Create the binding
DBBINDING Binding;
Binding.iOrdinal = ulColToFind;
Binding.dwPart = DBPART_VALUE | DBPART_STATUS | DBPART_LENGTH;
Binding.eParamIO = DBPARAMIO_INPUT;
Binding.pTypeInfo = NULL;
Binding.obValue = offsetof(FindValueInfo, pValue);
Binding.cbMaxLen = cbDataLength;
Binding.obLength = offsetof(FindValueInfo, cbLength);
Binding.obStatus = offsetof(FindValueInfo, dbsStatus);
Binding.dwMemOwner = DBMEMOWNER_CLIENTOWNED;
Binding.wType = wBindType | wByRefType;
Binding.pBindExt = NULL;
Binding.bPrecision = BYTE(TempCol.GetPrecision());
Binding.bScale = BYTE(TempCol.GetScale());
// Lets create the accessor.
if ( FAILED( m_pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 1, &Binding, sizeof(FindValueInfo)+cbDataLength,
&m_hRowsetFindAccessor, NULL)) )
goto CLEANUP;
fRet = TRUE;
CLEANUP:
if( !wByRefType )
{
PROVIDER_FREE(pMakeData);
}
return fRet;
}
//--------------------------------------------------------------------
//
//@mfunc: Create Accessor for the pFindValue argument to IRowsetFind::FindNextRows
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::CreateFindValueAccessor
(
DBCOMPAREOP CompareOp,
CTable * pCTable,
DBLENGTH ulRowNum,
DBORDINAL ulColNum,
DBTYPE wColType,
eSUBCOMPAREOP eSubCompare,
BOOL fUseStream,
DBCOMPAREOP * pwNewCompareOp,
DBPART dbPart,
HRESULT * phrExpected
)
{
BOOL fChanged = FALSE;
BOOL fRet = FALSE;
WCHAR wszData[2000];
CCol TempCol;
USHORT ulsize;
DBLENGTH cbDataLength = 0;
BYTE * pMakeData;
DBTYPE wVariantType = DBTYPE_EMPTY;
HRESULT hr = S_FALSE;
void * pvData=NULL;
pCTable->GetColInfo(ulColNum, TempCol);
if(!IsColumnMinimumFindable(&TempCol, CompareOp))
return FALSE;
if(eSubCompare != SUBOP_ALWAYS_NULL)
{
if(ulRowNum == 0)
{
// create data that won't match by creating data for a row that doesn't exist yet.
ulRowNum = pCTable->GetNextRowNumber();
}
TESTC(SUCCEEDED(hr = pCTable->MakeData(
wszData,
ulRowNum,
ulColNum,
PRIMARY,
wColType,
FALSE,
&wVariantType)));
}
if(hr == S_OK && wVariantType != DBTYPE_NULL)
{
if ( CompareOp & DBCOMPAREOPS_CASEINSENSITIVE )
{
// Change all the characters to lower case
WCHAR * pwsz = NULL;
for (pwsz=wszData; *pwsz; pwsz++)
*pwsz = MapWCHAR(*pwsz, LCMAP_LOWERCASE);
}
pMakeData = (BYTE *)WSTR2DBTYPE(wszData, ( wColType == DBTYPE_VARIANT ? wVariantType : wColType ) , &ulsize );
cbDataLength = GetDataLength(pMakeData, wColType, ulsize);
if ( !AlterData(&pMakeData, CompareOp, ( wColType == DBTYPE_VARIANT ? wVariantType : wColType ), &cbDataLength, eSubCompare))
{
if ( pwNewCompareOp )
*pwNewCompareOp = DBCOMPAREOPS_EQ;
}
if ( !fUseStream )
m_pFindValue = (BYTE *)PROVIDER_ALLOC(cbDataLength+sizeof(FindValueInfo));
if ( wColType == DBTYPE_VARIANT )
{
pvData = DBTYPE2VARIANT(pMakeData, wVariantType);
}
else
pvData = pMakeData;
if ( fUseStream )
{
ULONG cbTmp = 0;
ASSERT(cbDataLength <= ULONG_MAX);
m_pISeqStream = new CStorage();
m_pISeqStream->Write(pMakeData, (ULONG)cbDataLength, &cbTmp);
m_pFindValue = (BYTE *)m_pISeqStream;
}
else
{
// Set up our m_pFindValue struct to match offsets we give to our Binding.
switch ( wColType )
{
case DBTYPE_STR | DBTYPE_BYREF:
case DBTYPE_WSTR | DBTYPE_BYREF:
memcpy(m_pFindValue+offsetof(FindValueInfo, pValue), &pvData, cbDataLength);
break;
default:
memcpy(m_pFindValue+offsetof(FindValueInfo, pValue), pvData, cbDataLength);
}
}
}
if ( hr == S_FALSE || wVariantType == DBTYPE_NULL)
{
// The cell the test is trying to match contains a NULL.
// In most cases, this means the original CompareOp cannot be used
if (CompareOp != DBCOMPAREOPS_IGNORE)
{
// If the CompareOp is not IGNORE
if ( pwNewCompareOp )
*pwNewCompareOp = DBCOMPAREOPS_EQ;
if ( !fUseStream )
m_pFindValue = (BYTE *)PROVIDER_ALLOC(sizeof(DBSTATUS)+2*sizeof(DBLENGTH));
*(DBSTATUS *)(m_pFindValue+offsetof(FindValueInfo, dbsStatus)) = DBSTATUS_S_ISNULL;
// bogus length shouldn't matter since NULL status was set
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = MAXDBCOUNTITEM-1;
}
}
else
{
*(DBSTATUS *)(m_pFindValue+offsetof(FindValueInfo, dbsStatus)) = DBSTATUS_S_OK;
switch ( wColType )
{
case DBTYPE_WSTR:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength-sizeof(WCHAR);
break;
case DBTYPE_STR:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength-sizeof(char);
break;
default:
*(DBLENGTH *)(m_pFindValue+offsetof(FindValueInfo, cbLength)) = cbDataLength;
break;
}
}
// Create the binding
DBBINDING Binding;
DBOBJECT ObjectStruct;
if ( !fUseStream )
{
Binding.iOrdinal = ulColNum;
Binding.dwPart = DBPART_VALUE | DBPART_STATUS | DBPART_LENGTH;
Binding.eParamIO = DBPARAMIO_INPUT;
Binding.pTypeInfo = NULL;
Binding.pObject = NULL;
Binding.obValue = offsetof(FindValueInfo, pValue);
Binding.cbMaxLen = cbDataLength;
Binding.obLength = offsetof(FindValueInfo, cbLength);
Binding.obStatus = offsetof(FindValueInfo, dbsStatus);
Binding.dwMemOwner = DBMEMOWNER_CLIENTOWNED;
Binding.wType = wColType;
Binding.pBindExt = NULL;
Binding.bPrecision = BYTE(TempCol.GetPrecision());
Binding.bScale = BYTE(TempCol.GetScale());
}
else
{
ObjectStruct.dwFlags = STGM_WRITE;
ObjectStruct.iid = IID_ISequentialStream;
Binding.iOrdinal = ulColNum;
Binding.dwPart = DBPART_VALUE;
Binding.eParamIO = DBPARAMIO_INPUT;
Binding.pTypeInfo = NULL;
Binding.pObject = &ObjectStruct;
Binding.obValue = 0;
Binding.cbMaxLen = 0;
Binding.obLength = 0;
Binding.obStatus = 0;
Binding.dwMemOwner = DBMEMOWNER_CLIENTOWNED;
Binding.wType = DBTYPE_IUNKNOWN;
Binding.pBindExt = NULL;
Binding.bPrecision = 0;
Binding.bScale = 0;
}
// Lets create the accessor.
TESTC(SUCCEEDED(m_pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 1, &Binding,
sizeof(FindValueInfo)+cbDataLength, &m_hRowsetFindAccessor, NULL)))
goto CLEANUP;
fRet = TRUE;
CLEANUP:
PROVIDER_FREE(pvData);
return fRet;
}
BOOL TCIRowsetFind::ReleaseFindValueAccessor
(
DBTYPE wdbType
)
{
DBREFCOUNT cRefCount;
if(!m_pIAccessor)
return FALSE;
if( m_hRowsetFindAccessor )
{
m_pIAccessor->ReleaseAccessor(m_hRowsetFindAccessor, &cRefCount);
m_hRowsetFindAccessor = NULL;
}
//Release pData, accessor and bindings using privlib helpers because we used FillInputBindings
if (m_pFindValue)
{
TESTC(SUCCEEDED(ReleaseInputBindingsMemory(m_cFindBindings, m_rgFindBindings, m_pFindValue, TRUE))) ;
m_pFindValue = NULL;
}
CLEANUP:
SAFE_DELETE(m_pISeqStream);
if (m_rgFindBindings)
{
//FreeAccessorBindings(m_cFindBindings, m_rgFindBindings);
for(DBCOUNTITEM i=0; i<m_cFindBindings; i++)
{
PROVIDER_FREE(m_rgFindBindings[i].pObject);
}
PROVIDER_FREE(m_rgFindBindings);
}
m_cFindBindings = 0;
return (cRefCount == 0);
}
//--------------------------------------------------------------------
//
//@mfunc: Sets up accessor, pFindValue information and calls
// IRowsetFind::FindNextRows
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::CallFindNextRows
(
CTable * pCTable, // Table to find from
BYTE * pBookmark, // Bookmark to fetch from, if any
ULONG_PTR cbBookmark, // Length of bookmark
DBROWCOUNT lRowsToFetch, // maps to cRows
DBROWOFFSET lOffset, // maps to lOffset
DBORDINAL ulColToMatch, // Column to match
DBCOUNTITEM ulRowToMatch, // Is there a row where the find should happen? 0 - no match
HRESULT hrExpAccessor, // Expected HRESULT for Create Accessor Step
DBCOUNTITEM ulRowsExpected, // Expected count of rows
BOOL fReleaseRows, // flag to Release rows (optional)
DBCOMPAREOP CompareOp, // Any particular preference for comparing? (optional)
eSUBCOMPAREOP eSubCompare, // Some comparisions are rich enough to deserve a mulitple comparision operations
HROW * phRows, // optional arg if client wants to control row handle mem
BOOL fCheckRows, // verify rows by comparing data ?
BOOL fUseStream, // Use ISeqStream in the test
HRESULT hrExpFind // Second expected HRESULT for the FindNextRow step
)
{
m_rghRowsFound = ( phRows ? phRows : NULL );
BOOL fClientOwnedRowsMemory = phRows!=NULL;
BOOL fTestPass = TEST_PASS;
CCol TempCol;
DBTYPE wColType = DBTYPE_EMPTY;
DBCOMPAREOP wNewCompareOp = -1;
pCTable->GetColInfo(ulColToMatch, TempCol);
wColType = TempCol.GetProviderType();
// Not all test variations provide the same HRESULT for both operations.
// Default case is to expect they are the same unless otherwise specified
if( hrExpFind == -1 ) hrExpFind = hrExpAccessor;
//setup find value: note - DBPART_INVALID resolves to valid default value
fTestPass = CreateFindValueAccessor(CompareOp, pCTable, ulRowToMatch, ulColToMatch, wColType, eSubCompare, fUseStream, &wNewCompareOp, DBPART_INVALID, &hrExpAccessor);
TESTC(fTestPass);
if(wNewCompareOp != - 1)
CompareOp = wNewCompareOp;
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
CompareOp, cbBookmark, pBookmark, lOffset,
lRowsToFetch, &m_cRowsFound, &m_rghRowsFound);
// Verify HRESULT
if ( !CHECK(m_hr,hrExpFind) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// if FindNextRow failed, no need to validate returned rows
if (FAILED(m_hr))
{
goto CLEANUP;
}
// Verify m_cRowsFound
if ( !COMPARE(ulRowsExpected,m_cRowsFound) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Verify row positions of rows in m_rghRows.
if ( fCheckRows )
{
for ( ULONG i=0; i < ulRowsExpected; i ++ )
{
fTestPass = VerifyRowPosition(m_rghRowsFound[i],
(lRowsToFetch > 0 ? ulRowToMatch+i : ulRowToMatch-i),
pCTable);
if ( !COMPARE(fTestPass, TEST_PASS) )
goto CLEANUP;
}
}
// Cleanup
CLEANUP:
if ( fReleaseRows && m_cRowsFound > 0 && m_rghRowsFound)
{
m_pIRowset->ReleaseRows(m_cRowsFound, m_rghRowsFound, NULL, NULL, NULL);
m_cRowsFound = 0;
//free memory only if provider allocated it
if (!fClientOwnedRowsMemory)
PROVIDER_FREE(m_rghRowsFound);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
//--------------------------------------------------------------------
//
//@mfunc: Alters the data to according to the CompareOp
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::AlterData
(
BYTE ** ppMakeData,
DBCOMPAREOP TestCompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength,
eSUBCOMPAREOP eSubCompare
)
{
DBCOMPAREOP CompareOp = TestCompareOp & ~(DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE);
if ( (CompareOp == DBCOMPAREOPS_GE || CompareOp == DBCOMPAREOPS_LE ||
CompareOp == DBCOMPAREOPS_BEGINSWITH || CompareOp == DBCOMPAREOPS_CONTAINS) &&
eSubCompare == SUBOP_ALWAYS_EQ )
return TRUE;
switch ( CompareOp )
{
case DBCOMPAREOPS_EQ:
{
switch ( wColType )
{
// Because multiple varnumerics can
// map to the same value
case DBTYPE_VARNUMERIC:
if(!AlterVarnumericData((BYTE **)ppMakeData, DBCOMPAREOPS_EQ, pcbDataLength))
return FALSE;
}
break;
}
case DBCOMPAREOPS_BEGINSWITH:
case DBCOMPAREOPS_CONTAINS:
{
switch ( wColType )
{
case DBTYPE_WSTR:
case DBTYPE_STR:
case DBTYPE_BSTR:
if(!AlterCharacterData((void **)ppMakeData, CompareOp, wColType, pcbDataLength, eSubCompare))
return FALSE;
break;
case DBTYPE_NULL:
return FALSE;
default:
odtLog << L"Unexpected Type for CONTAINS: "<< wColType << ENDL;
return FALSE;
}
break;
}
case DBCOMPAREOPS_NOTBEGINSWITH:
case DBCOMPAREOPS_NOTCONTAINS:
{
switch ( wColType )
{
case DBTYPE_WSTR:
case DBTYPE_STR:
case DBTYPE_BSTR:
if(!AlterCharacterData((void **)ppMakeData, CompareOp, wColType, pcbDataLength, eSubCompare))
return FALSE;
break;
case DBTYPE_NULL:
return FALSE;
default:
odtLog << L"Unexpected Type for NOTCONTAINS or NOTBEGINSWITH: "<<wColType<< ENDL;
return FALSE;
}
break;
}
case DBCOMPAREOPS_GE:
case DBCOMPAREOPS_GT:
switch ( wColType )
{
case DBTYPE_WSTR:
case DBTYPE_STR:
case DBTYPE_BSTR:
if(!AlterCharacterData((void **)ppMakeData, CompareOp, wColType, pcbDataLength, eSubCompare))
return FALSE;
break;
case DBTYPE_I1:
case DBTYPE_I2:
case DBTYPE_I4:
case DBTYPE_I8:
case DBTYPE_UI1:
case DBTYPE_UI2:
case DBTYPE_UI4:
case DBTYPE_UI8:
case DBTYPE_R4:
case DBTYPE_R8:
case DBTYPE_NUMERIC:
case DBTYPE_DECIMAL:
case DBTYPE_CY:
case DBTYPE_DATE:
case DBTYPE_DBTIME:
case DBTYPE_DBDATE:
case DBTYPE_DBTIMESTAMP:
case DBTYPE_ERROR:
case DBTYPE_VARNUMERIC:
AlterNumericData(ppMakeData, CompareOp, wColType, pcbDataLength);
break;
case DBTYPE_NULL:
return FALSE;
default:
odtLog << L"Unexpected Type for GT/GE: " << wColType << ENDL;
return FALSE;
}
break;
case DBCOMPAREOPS_LT:
case DBCOMPAREOPS_LE:
switch ( wColType )
{
case DBTYPE_WSTR:
case DBTYPE_STR:
case DBTYPE_BSTR:
if(!AlterCharacterData((void **)ppMakeData, CompareOp, wColType, pcbDataLength, eSubCompare))
return FALSE;
break;
case DBTYPE_I1:
case DBTYPE_I2:
case DBTYPE_I4:
case DBTYPE_I8:
case DBTYPE_UI1:
case DBTYPE_UI2:
case DBTYPE_UI4:
case DBTYPE_UI8:
case DBTYPE_R4:
case DBTYPE_R8:
case DBTYPE_NUMERIC:
case DBTYPE_DECIMAL:
case DBTYPE_CY:
case DBTYPE_DATE:
case DBTYPE_DBTIME:
case DBTYPE_DBDATE:
case DBTYPE_DBTIMESTAMP:
case DBTYPE_ERROR:
case DBTYPE_VARNUMERIC:
if(!AlterNumericData(ppMakeData, CompareOp, wColType, pcbDataLength))
return FALSE;
break;
case DBTYPE_NULL:
return FALSE;
default:
odtLog << L"Unexpected Type for LT/LE: " << wColType << ENDL;
return FALSE;
}
break;
case DBCOMPAREOPS_NE:
// Alter the data
switch ( wColType )
{
case DBTYPE_BYTES:
((BYTE *)*ppMakeData)[0] = ~(*(BYTE *)*ppMakeData);
break;
case DBTYPE_WSTR:
case DBTYPE_BSTR:
case DBTYPE_STR:
if(!AlterCharacterData((void **)ppMakeData, DBCOMPAREOPS_LT, wColType, pcbDataLength, SUBOP_EMPTY))
return FALSE;
break;
case DBTYPE_BOOL:
if ( *(VARIANT_BOOL *)*ppMakeData == VARIANT_TRUE )
*(VARIANT_BOOL *)*ppMakeData = VARIANT_FALSE;
else
*(VARIANT_BOOL *)*ppMakeData = VARIANT_TRUE;
break;
case DBTYPE_NULL:
return FALSE;
case DBTYPE_GUID:
memset(*ppMakeData, 0xCA, sizeof(GUID));
break;
case DBTYPE_UDT:
odtLog << L"!!! AlterData NOT IMPLEMENTED for DBTYPE_UDT !!!" << ENDL;
return FALSE;
default:
if(!AlterNumericData(ppMakeData, DBCOMPAREOPS_LT, wColType, pcbDataLength))
return FALSE;
break;
}
break;
case DBCOMPAREOPS_IGNORE:
if( wColType == DBTYPE_BSTR )
{
BSTR bstrVal = *((BSTR*)(*ppMakeData));
// Jumble the first byte of data to test that it is actually ignored.
memset(bstrVal, 0xCA, 1);
}
else
{
// Jumble the first byte of data to test that it is actually ignored.
memset(*ppMakeData, 0xCA, 1);
}
break;
default:
break;
}
return TRUE;
}
BOOL TCIRowsetFind::AlterCharacterData
(
void ** ppMakeData,
DBCOMPAREOP CompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength,
eSUBCOMPAREOP eSubCompare
)
{
ASSERT(ppMakeData && *ppMakeData);
void * pMakeData = *ppMakeData;
DBLENGTH cchDataLength = 0;
DBLENGTH cbDataLength = *pcbDataLength;
if ( wColType == DBTYPE_WSTR )
cchDataLength = (cbDataLength - sizeof(WCHAR))/sizeof(WCHAR);
else if ( wColType == DBTYPE_BSTR )
cchDataLength = SysStringLen( *(BSTR *)(pMakeData) );
else if ( wColType == DBTYPE_STR )
cchDataLength = cbDataLength - sizeof(char);
switch ( CompareOp )
{
case DBCOMPAREOPS_NOTCONTAINS:
case DBCOMPAREOPS_NOTBEGINSWITH:
// all MakeData Strings begin with a digit or the letter 'H'
// use 'Q' to cause a match for NOTCONTAINS or NOTBEGINSWITH
switch ( wColType )
{
case DBTYPE_WSTR:
((WCHAR *)pMakeData)[0] = L'Q';
((WCHAR *)pMakeData)[1] = L'\0';
break;
case DBTYPE_STR:
((char *)pMakeData)[0] = 'Q';
((char *)pMakeData)[1] = '\0';
break;
case DBTYPE_BSTR:
{
(*(BSTR *)pMakeData)[0] = L'Q';
(*(BSTR *)pMakeData)[1] = L'\0';
SysReAllocString((BSTR *)pMakeData, *(BSTR *)pMakeData);
break;
}
default:
odtLog << L"Unexpected Type for NOTBEGINSWITH/NOTCONTAINS: " << wColType << ENDL;
return FALSE;
}
break;
case DBCOMPAREOPS_BEGINSWITH:
// blank out some of the last characters
switch ( wColType )
{
case DBTYPE_WSTR:
((WCHAR *)pMakeData)[cchDataLength-3] = L'\0';
break;
case DBTYPE_STR:
{
char *szTmp = CharPrevExA(CP_ACP, (char *)pMakeData, (char *)pMakeData+cchDataLength, 0);
*szTmp = '\0';
}
break;
case DBTYPE_BSTR:
{
(*(BSTR *)pMakeData)[cchDataLength-3] = L'\0';
SysReAllocString((BSTR *)pMakeData, *(BSTR *)pMakeData);
break;
}
default:
odtLog << L"Unexpected Type for BEGINSWITH: " << wColType << ENDL;
return FALSE;
}
break;
case DBCOMPAREOPS_CONTAINS:
switch ( eSubCompare )
{
case SUBOP_CONTAINS_BEGIN:
// Reduces to previous case
switch ( wColType )
{
case DBTYPE_WSTR:
((WCHAR *)pMakeData)[cchDataLength-3] = L'\0';
break;
case DBTYPE_STR:
{
char *szTmp = CharPrevExA(CP_ACP, (char *)pMakeData, (char *)pMakeData+cchDataLength, 0);
*szTmp = '\0';
}
break;
case DBTYPE_BSTR:
{
(*(BSTR *)pMakeData)[cchDataLength-3] = L'\0';
SysReAllocString((BSTR *)pMakeData, *(BSTR *)pMakeData);
break;
}
default:
odtLog << L"Unexpected Type for CONTAINS: " << wColType << ENDL;
return FALSE;
}
break;
case SUBOP_CONTAINS_MIDDLE:
case SUBOP_CONTAINS_END:
{
const int cchTrim = 2; // characters to trim
BYTE *pTmpBuf = (BYTE *)PROVIDER_ALLOC( (cchDataLength+1) * sizeof(WCHAR) );
switch ( wColType )
{
case DBTYPE_WSTR:
memcpy(pTmpBuf, (BYTE *)pMakeData+(cchTrim*sizeof(WCHAR)), (cchDataLength-cchTrim)*sizeof(WCHAR));
memcpy(pMakeData, pTmpBuf, (cchDataLength-cchTrim)*sizeof(WCHAR));
if ( eSubCompare == SUBOP_CONTAINS_END )
((WCHAR *)pMakeData)[cchDataLength-cchTrim] = L'\0';
else
((WCHAR *)pMakeData)[cchDataLength-(2*cchTrim)] = L'\0';
break;
case DBTYPE_STR:
{
char *szTmp = (char *)pMakeData;
szTmp = CharNextA((char *)pMakeData);
szTmp = CharNextA(szTmp);
ULONG_PTR cbTrim = szTmp - (char *)pMakeData ;
memcpy(pTmpBuf, (BYTE *)szTmp, cchDataLength-cbTrim);
memcpy(pMakeData, pTmpBuf, cchDataLength-cbTrim);
((char *)pMakeData)[cchDataLength-cbTrim] = '\0';
if ( eSubCompare == SUBOP_CONTAINS_END )
{
((char *)pMakeData)[cchDataLength-cbTrim] = '\0';
}
else
{
((char *)pMakeData)[cchDataLength-cbTrim] = '\0';
char *szTmp = CharPrevExA(CP_ACP, (char *)pMakeData, (char *)pMakeData+(cchDataLength-cbTrim), 0);
*szTmp = '\0';
}
}
break;
case DBTYPE_BSTR:
{
WCHAR * wsz = *(BSTR *)pMakeData;
memcpy(pTmpBuf, (BYTE *)wsz+(cchTrim*sizeof(WCHAR)), (cchDataLength-cchTrim)*sizeof(WCHAR));
memcpy(wsz, pTmpBuf, (cchDataLength-cchTrim)*sizeof(WCHAR));
if ( eSubCompare == SUBOP_CONTAINS_END )
((WCHAR *)wsz)[cchDataLength-cchTrim] = L'\0';
else
((WCHAR *)wsz)[cchDataLength-(2*cchTrim)] = L'\0';
SysReAllocString((BSTR *)pMakeData, *(BSTR *)pMakeData);
break;
}
default:
odtLog << L"Unexpected Type for CONTAINS: " << wColType << ENDL;
return FALSE;
}
PROVIDER_FREE(pTmpBuf);
break;
}
default:
ASSERT(!"Illegal Sub Compare Op");
}
break;
case DBCOMPAREOPS_GT:
case DBCOMPAREOPS_GE:
// truncate a character.
switch ( wColType )
{
case DBTYPE_WSTR:
cbDataLength -= sizeof(WCHAR);
((WCHAR *)pMakeData)[cchDataLength-1] = L'\0';
break;
case DBTYPE_STR:
{
char *szTmp = CharPrevExA(CP_ACP, (char *)pMakeData, (char *)pMakeData+cchDataLength, 0);
cbDataLength = (szTmp-(char *)pMakeData)+sizeof(char);
*szTmp = '\0';
break;
}
case DBTYPE_BSTR:
{
(*(BSTR *)pMakeData)[cchDataLength-1] = L'\0';
break;
}
default:
odtLog << L"Unexpected Type for GT/GE: " << wColType << ENDL;
return FALSE;
}
*pcbDataLength = cbDataLength;
break;
case DBCOMPAREOPS_LT:
case DBCOMPAREOPS_LE:
{
// add a character 'a'
void * pReAllocData = NULL;
switch ( wColType )
{
case DBTYPE_WSTR:
cbDataLength += sizeof(WCHAR);
pReAllocData = PROVIDER_ALLOC(cbDataLength);
wcscpy((WCHAR *)pReAllocData, (WCHAR *)pMakeData);
((WCHAR *)pReAllocData)[cchDataLength] = L'a';
((WCHAR *)pReAllocData)[cchDataLength+1] = L'\0';
PROVIDER_FREE(*ppMakeData);
*ppMakeData = pReAllocData;
break;
case DBTYPE_STR:
cbDataLength += sizeof(char);
pReAllocData = PROVIDER_ALLOC(cbDataLength);
strcpy((char *)pReAllocData, (char *)pMakeData);
((char *)pReAllocData)[cchDataLength] = 'a';
((char *)pReAllocData)[cchDataLength+1] = '\0';
PROVIDER_FREE(*ppMakeData);
*ppMakeData = pReAllocData;
break;
case DBTYPE_BSTR:
if( (cchDataLength+1) > ULONG_MAX )
return FALSE;
pReAllocData = SysAllocStringLen(NULL, (ULONG)(cchDataLength+1));
wcscpy((WCHAR *)pReAllocData, *(BSTR *)pMakeData);
((WCHAR *)pReAllocData)[cchDataLength] = L'a';
((WCHAR *)pReAllocData)[cchDataLength+1] = L'\0';
SysFreeString(*(BSTR *)pMakeData);
*(BSTR *)pMakeData = (BSTR)pReAllocData;
break;
default:
odtLog << L"Unexpected Type for LT/LE: " << wColType << ENDL;
return FALSE;
}
*pcbDataLength = cbDataLength;
}
break;
default:
ASSERT(!"Illegal Compare Op");
break;
}
switch ( wColType )
{
case DBTYPE_WSTR:
*pcbDataLength=(wcslen((WCHAR*)(*ppMakeData))+1)*sizeof(WCHAR);
break;
case DBTYPE_STR:
*pcbDataLength=(strlen((char*)(*ppMakeData))+1)*sizeof(char);
break;
}
return TRUE;
}
BOOL TCIRowsetFind::AlterNumericData
(
BYTE ** ppMakeData,
DBCOMPAREOP CompareOp,
DBTYPE wColType,
DBLENGTH * pcbDataLength
)
{
// Find value to increment, decrement by.
// If CompareOps = GT or GE, we set the find value to the backend value decremented so that
// the match will pick up the backend value
double dblChangeVal;
BYTE * pMakeData = *ppMakeData;
switch ( wColType )
{
case DBTYPE_I1:
case DBTYPE_I2:
case DBTYPE_I4:
case DBTYPE_I8:
case DBTYPE_UI1:
case DBTYPE_UI2:
case DBTYPE_UI4:
case DBTYPE_UI8:
case DBTYPE_CY:
case DBTYPE_NUMERIC:
case DBTYPE_DECIMAL:
case DBTYPE_ERROR:
if ( CompareOp == DBCOMPAREOPS_GT || CompareOp == DBCOMPAREOPS_GE )
dblChangeVal = -1;
else if ( CompareOp == DBCOMPAREOPS_LT || CompareOp == DBCOMPAREOPS_LE )
dblChangeVal = 1;
break;
case DBTYPE_R4:
if ( CompareOp == DBCOMPAREOPS_GT || CompareOp == DBCOMPAREOPS_GE )
dblChangeVal = -0.5;
else if ( CompareOp == DBCOMPAREOPS_LT || CompareOp == DBCOMPAREOPS_LE )
dblChangeVal = 0.5;
break;
case DBTYPE_R8:
if ( CompareOp == DBCOMPAREOPS_GT || CompareOp == DBCOMPAREOPS_GE )
dblChangeVal = -0.1;
else if ( CompareOp == DBCOMPAREOPS_LT || CompareOp == DBCOMPAREOPS_LE )
dblChangeVal = 0.1;
break;
case DBTYPE_VARNUMERIC:
break; // nothing to do - the test has only special cases for varnumeric
case DBTYPE_DATE:
case DBTYPE_DBTIME:
case DBTYPE_DBTIMESTAMP:
if ( CompareOp == DBCOMPAREOPS_GT || CompareOp == DBCOMPAREOPS_GE )
dblChangeVal = -1.0/1440.0; // one minute in OLE Date format
else if ( CompareOp == DBCOMPAREOPS_LT || CompareOp == DBCOMPAREOPS_LE )
dblChangeVal = 1.0/1440.0;
break;
case DBTYPE_DBDATE:
if ( CompareOp == DBCOMPAREOPS_GT || CompareOp == DBCOMPAREOPS_GE )
dblChangeVal = -1.0; // one day in OLE Date format
else if ( CompareOp == DBCOMPAREOPS_LT || CompareOp == DBCOMPAREOPS_LE )
dblChangeVal = 1.0;
break;
default:
ASSERT(!"Shouldn't get here");
}
double dblValue = dblChangeVal;
// Perform data change
switch ( wColType )
{
case DBTYPE_I1:
*(signed char *)pMakeData += (signed char)(dblValue);
break;
case DBTYPE_I2:
*(short *)pMakeData += short(dblValue);
break;
case DBTYPE_I4:
*(long *)pMakeData += long(dblValue);
break;
case DBTYPE_I8:
*(__int64 *)pMakeData += (__int64)(dblValue);
break;
case DBTYPE_UI1:
*(unsigned char *)pMakeData += (char)(dblValue);
break;
case DBTYPE_UI2:
*(unsigned short *)pMakeData += (short)(dblValue);
break;
case DBTYPE_UI4:
*(unsigned long *)pMakeData += (long)(dblValue);
break;
case DBTYPE_UI8:
*(__int64 *)pMakeData += (__int64)(dblValue);
break;
case DBTYPE_CY:
*(__int64 *)pMakeData += (__int64)(dblValue);
break;
case DBTYPE_NUMERIC:
AddShortToNumeric((DB_NUMERIC *)pMakeData, short(dblValue));
break;
case DBTYPE_DECIMAL:
AddShortToDecimal((DECIMAL *)pMakeData, short(dblValue));
break;
case DBTYPE_ERROR:
*(long *)pMakeData += long(dblValue);
break;
case DBTYPE_R4:
*(float *)pMakeData += float(dblValue);
break;
case DBTYPE_R8:
*(double *)pMakeData += double(dblValue);
break;
case DBTYPE_DATE:
*(double *)pMakeData += double(dblValue);
break;
case DBTYPE_VARNUMERIC:
if(!AlterVarnumericData(ppMakeData, CompareOp, pcbDataLength))
return FALSE;
break;
case DBTYPE_DBTIME:
{
LONG lSeconds;
DBTIME *time = (DBTIME *)pMakeData;
lSeconds = time->hour * 3600 + time->minute * 60 + time->second + LONG(dblValue);
ASSERT(lSeconds < 86400 );
time->hour = (USHORT)(lSeconds / 3600);
time->minute = (USHORT)((lSeconds % 3600) / 60);
time->second = (USHORT)(lSeconds % 60);
break;
}
case DBTYPE_DBTIMESTAMP:
{
SYSTEMTIME SystemTime;
DATE dOleDate;
SystemTime.wYear = ((DBTIMESTAMP *)pMakeData)->year;
SystemTime.wMonth = ((DBTIMESTAMP *)pMakeData)->month;
SystemTime.wDay = ((DBTIMESTAMP *)pMakeData)->day;
SystemTime.wHour = ((DBTIMESTAMP *)pMakeData)->hour;
SystemTime.wMinute = ((DBTIMESTAMP *)pMakeData)->minute;
SystemTime.wSecond = ((DBTIMESTAMP *)pMakeData)->second;
SystemTimeToVariantTime(&SystemTime, &dOleDate);
dOleDate += dblValue;
VariantTimeToSystemTime(dOleDate, &SystemTime);
((DBTIMESTAMP *)pMakeData)->year = SystemTime.wYear;
((DBTIMESTAMP *)pMakeData)->month = SystemTime.wMonth;
((DBTIMESTAMP *)pMakeData)->day = SystemTime.wDay;
((DBTIMESTAMP *)pMakeData)->hour = SystemTime.wHour;
((DBTIMESTAMP *)pMakeData)->minute = SystemTime.wMinute;
((DBTIMESTAMP *)pMakeData)->second = SystemTime.wSecond;
}
break;
case DBTYPE_DBDATE:
{
SYSTEMTIME SystemTime;
DATE dOleDate;
SystemTime.wYear = ((DBDATE *)pMakeData)->year;
SystemTime.wMonth = ((DBDATE *)pMakeData)->month;
SystemTime.wDay = ((DBDATE *)pMakeData)->day;
SystemTimeToVariantTime(&SystemTime, &dOleDate);
dOleDate += dblValue;
VariantTimeToSystemTime(dOleDate, &SystemTime);
((DBDATE *)pMakeData)->year = SystemTime.wYear;
((DBDATE *)pMakeData)->month = SystemTime.wMonth;
((DBDATE *)pMakeData)->day = SystemTime.wDay;
}
break;
default:
ASSERT(!"Shouldn't get here");
}
return TRUE;
}
BOOL TCIRowsetFind::AlterVarnumericData
(
BYTE ** ppMakeData,
DBCOMPAREOP CompareOp,
DBLENGTH * pcbDataLength
)
{
// 3 "Equal" options
// a) s_VarNumEqOption=0 => leave the varnum alone
// b) s_VarNumEqOption=1 => inc. scale, mult by 10
// c) s_VarNumEqOption=2 => dec. scale, div by 10
static long s_VarNumEqOption = 0;
static SBYTE s_MaxScale = 127; // max possible VarNum scale
static SBYTE s_MinScale = -128;// min possible VarNum scale
BYTE bRemainder=0;
DB_VARNUMERIC * pVarNum = (DB_VARNUMERIC *)*ppMakeData;
DB_VARNUMERIC * pNewVarNum = NULL;
ULONG cbVarNumeric;
ASSERT(ppMakeData && *ppMakeData && pcbDataLength);
ASSERT(*pcbDataLength <= MAX_VARNUM_BYTE_SIZE); // max varnumeric byte length is 111.
cbVarNumeric = (ULONG) *pcbDataLength;
if (pVarNum->sign==0) // if negative
{
if (CompareOp==DBCOMPAREOPS_GT || CompareOp==DBCOMPAREOPS_GE)
CompareOp=DBCOMPAREOPS_LT;
else if (CompareOp==DBCOMPAREOPS_LT || CompareOp==DBCOMPAREOPS_LE)
CompareOp=DBCOMPAREOPS_GT;
}
switch (CompareOp)
{
case DBCOMPAREOPS_EQ:
switch (s_VarNumEqOption)
{
case 0:
break;
case 1:
{
DB_VARNUMERIC *pNewVarNum=NULL;
if(pVarNum->scale==s_MaxScale || pVarNum->precision==255)
return FALSE;
pNewVarNum = (DB_VARNUMERIC *)PROVIDER_ALLOC(cbVarNumeric+1);
if (!pNewVarNum)
return FALSE;
memset(pNewVarNum, 0, cbVarNumeric+1);
memcpy(pNewVarNum, pVarNum, cbVarNumeric);
AddCharToVarNumericVal(L'0',pNewVarNum, USHORT(cbVarNumeric+1)-sizeof(DB_VARNUMERIC)+1);
pNewVarNum->precision++; // inc to compensate for new digit
pNewVarNum->scale++; // inc to the scale to compensate for mult by 10
PROVIDER_FREE(pVarNum);
*ppMakeData = (BYTE *)pNewVarNum;
(*pcbDataLength)++;
}
break;
case 2:
{
DB_VARNUMERIC *pTempVar=NULL;
pTempVar = (DB_VARNUMERIC *)PROVIDER_ALLOC(cbVarNumeric);
if (!pTempVar)
return FALSE;
memcpy(pTempVar, pVarNum, cbVarNumeric);
if (pVarNum->scale==s_MinScale)
return FALSE;
VarNumericDiv10Rem(pTempVar, pTempVar, (cbVarNumeric)-sizeof(DB_VARNUMERIC)+1, &bRemainder);
if(bRemainder!=0)
return FALSE; // not able to guarantee unchanged value
// this can work, so copy the contents
memcpy(pVarNum, pTempVar, cbVarNumeric);
PROVIDER_FREE(pTempVar);
pVarNum->precision--; // decrement the precision to compensate for div by 10
break;
}
default:
ASSERT(!"Bad Eq option");
break;
}
s_VarNumEqOption = (s_VarNumEqOption+1)%3;
break;
case DBCOMPAREOPS_GT:
case DBCOMPAREOPS_GE:
// make value smaller.
if (pVarNum->scale==s_MaxScale)
{
VarNumericDiv10Rem(pVarNum, pVarNum, cbVarNumeric, &bRemainder);
pVarNum->precision--; // decrement the precision to compensate for div by 10
// it's possible that the value remains unchanged.
// force it to be less
if (bRemainder==0)
pVarNum->scale++; // incrementing the scale is safe even though pVarNum->scale == s_MaxScale
} // because the scale is decremented by the call to VarNumericDiv10Rem.
else
pVarNum->scale++; // just increment the scale
break;
case DBCOMPAREOPS_LT:
case DBCOMPAREOPS_LE:
// make value larger
if (pVarNum->scale==s_MinScale)
{
// Add a digit to the number as long as it doesn't overflow
// a varnum's max precision = 255
if (pVarNum->precision==255)
return FALSE;
pNewVarNum = (DB_VARNUMERIC *)PROVIDER_ALLOC(cbVarNumeric+1);
if (!pNewVarNum)
return FALSE;
memset(pNewVarNum, 0, cbVarNumeric+1);
memcpy(pNewVarNum, pVarNum, cbVarNumeric);
AddCharToVarNumericVal(L'1', pNewVarNum, USHORT(cbVarNumeric)-sizeof(DB_VARNUMERIC)+1);
PROVIDER_FREE(pVarNum);
pNewVarNum->precision++; // inc to compensate for new digit
*ppMakeData = (BYTE *)pNewVarNum;
(*pcbDataLength)++;
}
else
pVarNum->scale--; // just decrement the scale
break;
default:
ASSERT(!"Bad compare option to AlterVarnumericData");
}
return TRUE;
}
BOOL TCIRowsetFind::BindingTypeTest
(
CTable * pCTable,
DBTYPE wBindingType
)
{
HRESULT hr = E_FAIL;
BOOL fTestPass = TEST_SKIPPED;
DBPROPID guidProperty[1];
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained;
DBORDINAL ulColToFind;
DBTYPE wColType = DBTYPE_EMPTY;
CCol TempCol;
DBORDINAL ulColNum = pCTable->CountColumnsOnTable();
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
guidProperty[0] = DBPROP_IRowsetLocate;
//open rowset, and accessor.
TESTC(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
1,guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE));
TESTC(GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_EQ, FALSE, &wColType));
TESTC_(m_pIConvertType->CanConvert(wBindingType, wColType, DBCONVERTFLAGS_COLUMN), S_OK);
for(DBORDINAL ulColIndex = 1; ulColIndex <= ulColNum; ulColIndex++)
{
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
pCTable->GetColInfo(ulColIndex, TempCol);
wColType = TempCol.GetProviderType();
TEST2C_(hr=m_pIConvertType->CanConvert(wBindingType, wColType, DBCONVERTFLAGS_COLUMN), S_OK, S_FALSE);
if (hr==S_FALSE)
continue;
TESTC(fTestPass = CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, ulColToFind, wBindingType, SUBOP_EMPTY, false, NULL));
fTestPass = TEST_FAIL;
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor,
m_pFindValue, DBCOMPAREOPS_EQ, 0, NULL, 0,
1, &cRowsObtained, &phrow);
if (m_hr != S_OK)
{
odtLog<<L"Error at ColIndex "<<ulColToFind<<L" Binding type = "<<wBindingType<<L"; column type = "<<wColType<< ENDL;
odtLog<<L"-------------------------------------------------------------"<< ENDL;
}
TESTC_(m_hr, S_OK);
TESTC(cRowsObtained==1);
TESTC(VerifyRowPosition(phrow[0], 1, g_pCTable));
if ( cRowsObtained > 0 && phrow)
{
m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL);
cRowsObtained = 0;
if (phrow)
PROVIDER_FREE(phrow);
}
}
fTestPass = TEST_PASS;
CLEANUP:
if ( cRowsObtained > 0 && phrow)
{
m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL);
cRowsObtained = 0;
if (phrow)
PROVIDER_FREE(phrow);
}
ReleaseFindValueAccessor(wBindingType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
BOOL TCIRowsetFind::CompareOpTest
(
CTable * pCTable,
DBCOMPAREOP CompareOp,
eSUBCOMPAREOP eSubCompare,
BOOL fUseStream
)
{
if(!pCTable || !m_pIRowset)
{
odtLog << L"ASSERT (pCTable && m_pIRowset)" <<ENDL;
return TEST_FAIL;
}
// Service components do not support conversion to streams
if (fUseStream && ((GetModInfo()->UseServiceComponents() & SERVICECOMP_INVOKE) == SERVICECOMP_INVOKE))
{
return TEST_SKIPPED;
}
BOOL fTestPass = TEST_PASS, fSubTestPass = TEST_FAIL;
CCol TempCol;
DBORDINAL ulColNum = pCTable->CountColumnsOnTable();
DBCOUNTITEM ulRowCount = pCTable->GetRowsOnCTable();
//CLEANUP from previous variations: need this for RestartPosition to succeed
if( m_rghRowsFound && m_cRowsFound >0 && m_rghRowsFound)
{
m_pIRowset->ReleaseRows(m_cRowsFound, m_rghRowsFound, NULL, NULL, NULL);
PROVIDER_FREE(m_rghRowsFound);
m_cRowsFound = 0;
}
for(DBORDINAL ulColIndex = 1; ulColIndex <= ulColNum; ulColIndex++)
{
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
g_pCTable->GetColInfo(ulColIndex, TempCol);
// Make Sure it's updateable and searchable, otherwise it may be an
// autoinc column that we don't know the value of.
if (!IsColumnMinimumFindable(&TempCol, CompareOp) || (fUseStream && (!TempCol.GetIsLong() ||
(TempCol.GetProviderType() != DBTYPE_STR &&
TempCol.GetProviderType() != DBTYPE_WSTR &&
TempCol.GetProviderType() != DBTYPE_BYTES))))
continue;
for ( ULONG ulRowIndex = 1; ulRowIndex <= ulRowCount+1; ulRowIndex++ )
{
HRESULT hrExp1 = ulRowIndex <= ulRowCount ? S_OK : DB_S_ENDOFROWSET;
ULONG ulRow = ulRowIndex <= ulRowCount ? 1 : 0;
BOOL bVerify = TRUE;
WCHAR wszName[256];
wcscpy(wszName, TempCol.GetProviderTypeName());
// Expect DB_E_BADCOMPAREOP when the data type is "image" and the compare operator is not DBCOMPAREOPS_IGNORE
// Basically this is the only workaround not related to DBCOMPAREOPS_IGNORE. Everything else is.
if( wcscmp(wszName, L"image") == 0 && CompareOp != DBCOMPAREOPS_IGNORE )
hrExp1 = DB_E_BADCOMPAREOP;
// Dont bother to verify data of returned rows when compare operator is DBCOMPAREOPS_IGNORE. Too many errors on specific
// row / column combinations. Trying to make a table and check pass / fail for each would be difficult. So were just skipping.
// Note all other compare operators are working fine.
if( CompareOp == DBCOMPAREOPS_IGNORE )
bVerify = FALSE;
// It was explained that the data in the tables is generated with NULLs in the spots where the row / column numbers
// intersect. IE r1c1, r2c2, etc. It would appear to be an issue with NULL data and DBCOMPAREOPS_IGNORE. Does not
// which data type is used in the "pFindValue" field, or whether we use SQLOLEDB or MSDASQL/SQL. Its always the
// case where ColumnIndex = RowIndex.
// NOTE There are 3 specific exceptions below.
if( CompareOp == DBCOMPAREOPS_IGNORE && ulColIndex == ulRowIndex )
hrExp1 = E_INVALIDARG;
HRESULT hrExp2 = hrExp1;
fSubTestPass =
CallFindNextRows
(
pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
ulColIndex, // Which column to match
ulRowIndex, // row to match
hrExp1, // HRESULT to verify
ulRow, // How many rows to expect.
TRUE, // Release Rows
CompareOp, // Specifically ask for a compare Op
eSubCompare, // Sub Comparision option
NULL, // Use client or provider memory, default=provider
bVerify, // verify rows by comparing data ?
fUseStream, // use fstream
hrExp2 // HRESULT for actual operation
);
if ( fSubTestPass == TEST_FAIL )
{
fTestPass = TEST_FAIL;
odtLog<<"Error at ColName "<< TempCol.GetColName()<<L", ColIndex "<<ulColIndex<<" and at RowIndex "<<ulRowIndex<< ENDL;
odtLog<<"-------------------------------------------------------------"<< ENDL;
break;
}
}
}
return fTestPass;
}
BOOL TCIRowsetFind::DeleteRow
(
CTable * pCTable,
DBCOUNTITEM ulRowToDelete
)
{
ASSERT(pCTable && ulRowToDelete >0 && ULONG(g_lRowLast) >= ulRowToDelete);
DBCOUNTITEM cRowsObtained = 0;
HROW * pHRow = NULL;
IRowsetChange * pIRowsetChange = NULL;
//get the row handle for row to delete
TESTC_(m_pIRowset->GetNextRows(NULL, ulRowToDelete-1,1,&cRowsObtained,&pHRow),S_OK);
COMPARE(cRowsObtained, 1);
//QI for IRowsetChange pointer
TESTC_(m_pIRowsetFind->QueryInterface(IID_IRowsetChange,
(void **)&pIRowsetChange),S_OK);
//delete the row
TESTC_(pIRowsetChange->DeleteRows(NULL,1,pHRow,NULL),S_OK);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
if(pHRow)
{
CHECK(m_pIRowset->ReleaseRows(1,pHRow,NULL,NULL,NULL),S_OK);
PROVIDER_FREE(pHRow);
}
//restart the cursor position
if(!CHECK(m_pIRowset->RestartPosition(NULL),S_OK))
return FALSE;
return TRUE;
}
DWORD TCIRowsetFind::TC_FindCompareOps
(
DBID * pColDBID
)
{
return GetFindCompareOps(m_pIRowset, pColDBID);
}
//--------------------------------------------------------------------
//
//@mfunc: verify that updating / deleting rows is OK against this provider.
//
// The result of this particular function is independant of whether the provider
// allows updates/deletes. The focus is rather whether deleting a row will
// cause the table to fall into an "unknown" state.
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::AlteringRowsIsOK()
{
// If a specific table was set on the backend, assume we cannot alter it
// unless we have a file telling us how to regenerate the table.
if ( GetModInfo()->GetTableName() && !GetModInfo()->GetFileName() )
return FALSE;
else
return TRUE;
}
BOOL TCIRowsetFind::IsColumnMinimumFindable(CCol *pCol, DBCOMPAREOP CompareOp)
{
DBTYPE wTargetType;
if(!ValidateCompareOp ( TC_FindCompareOps(pCol->GetColID()), CompareOp ))
return FALSE;
CompareOp &= ~( DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE );
if ( !pCol->GetUpdateable())
return FALSE; // autoinc column we don't know the value of
wTargetType = pCol->GetProviderType();
if(wTargetType == DBTYPE_VARIANT)
return FALSE;
return IsTypeFindable(wTargetType, CompareOp);
}
BOOL TCIRowsetFind::IsTypeFindable(DBTYPE wType, DBCOMPAREOP CompareOp, DBTYPE wSubType)
{
CompareOp &= ~( DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE );
if ( wType == DBTYPE_EMPTY || wType == DBTYPE_NULL || wType == DBTYPE_UDT)
return FALSE;
else if(wType == DBTYPE_VARIANT)
return FALSE;
if (IsStringCompareOp(CompareOp) && !IsStringType(wType))
return FALSE;
if ((wType == DBTYPE_BOOL ||
wType == DBTYPE_ERROR ||
wType == DBTYPE_GUID ||
wType == DBTYPE_BYTES ) &&
(CompareOp == DBCOMPAREOPS_GE ||
CompareOp == DBCOMPAREOPS_GT ||
CompareOp == DBCOMPAREOPS_LE ||
CompareOp == DBCOMPAREOPS_LT ))
return FALSE;
return TRUE;
}
BOOL TCIRowsetFind::IsStringType(DBTYPE wType)
{
return (wType == DBTYPE_STR || wType == DBTYPE_WSTR || wType == DBTYPE_BSTR);
}
BOOL TCIRowsetFind::IsStringCompareOp(DBCOMPAREOP CompareOp)
{
CompareOp &= ~( DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE );
return (CompareOp == DBCOMPAREOPS_CONTAINS ||
CompareOp == DBCOMPAREOPS_NOTCONTAINS ||
CompareOp == DBCOMPAREOPS_BEGINSWITH ||
CompareOp == DBCOMPAREOPS_NOTBEGINSWITH );
}
BOOL TCIRowsetFind::IsColumnFindable
(
CCol * pCol,
DBCOMPAREOP CompareOp
)
{
CompareOp &= ~( DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE );
// If the column is autoinc then we don't know the row values
if(!pCol->GetUpdateable())
return FALSE;
// Some types like DBTYPE_BOOL, DBTYPE_NULL can't guarantee a uniqueness property that the
// test needs.
if(!IsDBTYPEFindable(pCol->GetProviderType()))
return FALSE;
if(pCol->GetProviderType() == DBTYPE_VARIANT)
{
if(!IsDBTYPEFindable(pCol->GetSubType()))
return FALSE;
if( (CompareOp == DBCOMPAREOPS_CONTAINS || CompareOp == DBCOMPAREOPS_BEGINSWITH ) &&
pCol->GetSubType() != DBTYPE_BSTR)
return FALSE;
else
return ValidateCompareOp(TC_FindCompareOps(pCol->GetColID()), CompareOp);
}
return ValidateCompareOp (TC_FindCompareOps(pCol->GetColID()), CompareOp);
}
HRESULT TCIRowsetFind::RestartRowPosition()
{
HRESULT hr = m_pIRowset->RestartPosition(NULL);
if ( hr == S_OK || hr == DB_S_COMMANDREEXECUTED )
return S_OK;
else
return E_FAIL;
}
//--------------------------------------------------------------------
//
//@mfunc: Get the Variable Length and Updatable column
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::GetVariableLengthStrAndUpdatable
(
DBORDINAL * pulColNum,
DBCOMPAREOP CompareOp,
BOOL fGetLongStr,
DBTYPE * pwType
)
{
DBCOUNTITEM cColsCount;
DBCOUNTITEM cColsInTable = 0;
CCol TempCol;
//make sure a Rowset has been opened on the table
if(!m_pTable)
return FALSE;
//initialization
*pulColNum=0;
cColsInTable = m_pTable->CountColumnsOnTable();
for(cColsCount=1;cColsCount<=cColsInTable;cColsCount++)
{
DBTYPE TargetType = DBTYPE_EMPTY;
m_pTable->GetColInfo(cColsCount, TempCol);
if ( TempCol.GetProviderType() == DBTYPE_VARIANT )
TargetType = TempCol.GetSubType();
else
TargetType = TempCol.GetProviderType();
if( ( DBTYPE_STR == TargetType || DBTYPE_WSTR == TargetType || DBTYPE_BSTR == TargetType )
&&
(TempCol.GetUpdateable())
&&
(IsColumnMinimumFindable(&TempCol, CompareOp))
&&
(fGetLongStr == TempCol.GetIsLong())
)
{
(*pulColNum)=TempCol.GetColNum();
if (pwType)
(*pwType)=TempCol.GetProviderType();
break;
}
}
return (*pulColNum != 0 );
}
//--------------------------------------------------------------------
//
//@mfunc: Get first Non-Nullable column
//
//--------------------------------------------------------------------
BOOL TCIRowsetFind::GetNonNullableCol
(
DBORDINAL * pulColNum,
DBCOMPAREOP CompareOp,
BOOL fGetLongStr,
DBTYPE * pwType
)
{
DBORDINAL cColsCount;
DBORDINAL cColsInTable = 0;
CCol TempCol;
//make sure a Rowset has been opened on the table
if(!m_pTable)
return FALSE;
//initialization
*pulColNum=0;
cColsInTable = m_pTable->CountColumnsOnTable();
for(cColsCount=1;cColsCount<=cColsInTable;cColsCount++)
{
DBTYPE TargetType = DBTYPE_EMPTY;
m_pTable->GetColInfo(cColsCount, TempCol);
if (!TempCol.GetNullable() && IsColumnMinimumFindable(&TempCol, CompareOp))
{
(*pulColNum)=TempCol.GetColNum();
if (pwType)
(*pwType)=TempCol.GetProviderType();
break;
}
}
return (*pulColNum != 0 );
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_TEST_CASE_MAP(No_Properties)
//--------------------------------------------------------------------
// @class no properties set
//
class No_Properties : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(No_Properties,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookmark=NULL,cRows=1,fSkip=1. Traverse rowset by matching current row until DB_S_ENDOF_ROWSET
int Variation_1();
// @cmember pBookmark=NULL, cRows=1, match middle. Again, pBookmark=NULL, cRows=1 and Verify DB_S_ENDOFROWSET
int Variation_2();
// @cmember pBookmark=NULL, cRows=1, and match 2nd. Again pBookmark=NULL, cRows=3, match 4th. S_OK and 3 row handles
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(No_Properties)
#define THE_CLASS No_Properties
BEG_TEST_CASE(No_Properties, TCIRowsetFind, L"no properties set")
TEST_VARIATION(1, L"pBookmark=NULL,cRows=1,fSkip=1. Traverse rowset by matching current row until DB_S_ENDOF_ROWSET")
TEST_VARIATION(2, L"pBookmark=NULL, cRows=1, match middle. Again, pBookmark=NULL, cRows=1 and Verify DB_S_ENDOFROWSET")
TEST_VARIATION(3, L"pBookmark=NULL, cRows=1, and match 2nd. Again pBookmark=NULL, cRows=3, match 4th. S_OK and 3 row handles")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(FetchBackwards)
//--------------------------------------------------------------------
// @class Test FetchBackwards property
//
class FetchBackwards : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(FetchBackwards,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookMark=NULL,cRows=1 and match 1st row. FindNext, cRows=-1 matching same row. Verify S_OK
int Variation_1();
// @cmember pBookMark=NULL, cRows=3 and Match 1st row. FindNext, cRows=-2 and match 3rd row. Verify S_OK and 3rd and 2nd rows
int Variation_2();
// @cmember pBookmark=NULL,cRows=1 nd match last row. FindNext wiht cRows=-2,fSkip=0 and match 3rd row. Verify S_OK and hrows.
int Variation_3();
// @cmember pBookMark=NULL,cRows=1 and match last row. FindNext, cRows=-6, match last row. Verify DB_S_ENDOFROWSET and hrows
int Variation_4();
// @cmember pBookmark=NULL, cRows=1, and match last. pBookmark=NULL, cRows=3. Offset=1 and mattch 2nd row. Verify DB_S_ENDOFROWSET.
int Variation_5();
// @cmember pBookmark=NULL, cRows=1 and match last. Loop with cRows=-1 until DB_S_ENDOFROWSET.
int Variation_6();
// @cmember pBookmark=NULL, Match next to last. FindNext with cRows=-1 and Offset=2. Verify DB_S_ENDOFROWSET
int Variation_7();
// @cmember Test that cRows=0 doesn't affect find direction
int Variation_8();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(FetchBackwards)
#define THE_CLASS FetchBackwards
BEG_TEST_CASE(FetchBackwards, TCIRowsetFind, L"Test FetchBackwards property")
TEST_VARIATION(1, L"pBookMark=NULL,cRows=1 and match 1st row. FindNext, cRows=-1 matching same row. Verify S_OK")
TEST_VARIATION(2, L"pBookMark=NULL, cRows=3 and Match 1st row. FindNext, cRows=-2 and match 3rd row. Verify S_OK and 3rd and 2nd rows")
TEST_VARIATION(3, L"pBookmark=NULL,cRows=1 nd match last row. FindNext wiht cRows=-2,fSkip=0 and match 3rd row. Verify S_OK and hrows.")
TEST_VARIATION(4, L"pBookMark=NULL,cRows=1 and match last row. FindNext, cRows=-6, match last row. Verify DB_S_ENDOFROWSET and hrows")
TEST_VARIATION(5, L"pBookmark=NULL, cRows=1, and match last. pBookmark=NULL, cRows=3. Offset=1 and mattch 2nd row. Verify DB_S_ENDOFROWSET.")
TEST_VARIATION(6, L"pBookmark=NULL, cRows=1 and match last. Loop with cRows=-1 until DB_S_ENDOFROWSET.")
TEST_VARIATION(7, L"pBookmark=NULL, Match next to last. FindNext with cRows=-1 and Offset=2. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(8, L"Test that cRows=0 doesn't affect find direction")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ScrollBackwards)
//--------------------------------------------------------------------
// @class Test ScrollBackwards property
//
class ScrollBackwards : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ScrollBackwards,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookMark=DBBMK_FIRST,cRows=1 and match 2nd row. Verify S_OK and one row handle
int Variation_1();
// @cmember pBookMark=DBBMK_LAST,cRows=1 and Match last row. Verify S_OK and one row handle.
int Variation_2();
// @cmember pBookmark=DBBMK_LAST, cRows=1, and match last. Verify S_OK
int Variation_3();
// @cmember *pBookmark=DBBMK_FIRST, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET
int Variation_4();
// @cmember pBookmark=NULL, cRows=1, and match middle. FindNext with Offset=-3, cRows=3 and match row preceding middle row.
int Variation_5();
// @cmember pBookmark=NULL, cRows=1, and match last. FindNext with cRows=1, Offset=-1 and match last. Verify S_OK
int Variation_6();
// @cmember pBookmark=NULL, cRows=1, Loffset=-# of rows. Verify DB_S_ENDOFROWSET
int Variation_7();
// @cmember pBookmark=NULL,cRows=1, Offset=-2. Verify #of rows-1 row fetched. Cursor is after next to last row
int Variation_8();
// @cmember pBookmark=NULL, cRows=1, Loffset=-#of rows+1
int Variation_9();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(ScrollBackwards)
#define THE_CLASS ScrollBackwards
BEG_TEST_CASE(ScrollBackwards, TCIRowsetFind, L"Test ScrollBackwards property")
TEST_VARIATION(1, L"pBookMark=DBBMK_FIRST,cRows=1 and match 2nd row. Verify S_OK and one row handle")
TEST_VARIATION(2, L"pBookMark=DBBMK_LAST,cRows=1 and Match last row. Verify S_OK and one row handle.")
TEST_VARIATION(3, L"pBookmark=DBBMK_LAST, cRows=1, and match last. Verify S_OK")
TEST_VARIATION(4, L"*pBookmark=DBBMK_FIRST, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(5, L"pBookmark=NULL, cRows=1, and match middle. FindNext with Offset=-3, cRows=3 and match row preceding middle row.")
TEST_VARIATION(6, L"pBookmark=NULL, cRows=1, and match last. FindNext with cRows=1, Offset=-1 and match last. Verify S_OK")
TEST_VARIATION(7, L"pBookmark=NULL, cRows=1, Loffset=-# of rows. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(8, L"pBookmark=NULL,cRows=1, Offset=-2. Verify #of rows-1 row fetched. Cursor is after next to last row")
TEST_VARIATION(9, L"pBookmark=NULL, cRows=1, Loffset=-#of rows+1")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(CanHoldRows)
//--------------------------------------------------------------------
// @class Test DBPROP can hold row property
//
class CanHoldRows : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(CanHoldRows,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Get 1,2 row. Get 2,3,4 rows. S_OK
int Variation_1();
// @cmember Get 1,2 rows. Get 3 row.
int Variation_2();
// @cmember Get all rows with GetNextRows. RestartPosition. FindNext with pBookmark=NULL, Offset=1, cRows=1 and match 2nd. Verify S_OK
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(CanHoldRows)
#define THE_CLASS CanHoldRows
BEG_TEST_CASE(CanHoldRows, TCIRowsetFind, L"Test DBPROP can hold row property")
TEST_VARIATION(1, L"Get 1,2 row. Get 2,3,4 rows. S_OK")
TEST_VARIATION(2, L"Get 1,2 rows. Get 3 row.")
TEST_VARIATION(3, L"Get all rows with GetNextRows. RestartPosition. FindNext with pBookmark=NULL, Offset=1, cRows=1 and match 2nd. Verify S_OK")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Scroll_and_Fetch)
//--------------------------------------------------------------------
// @class Test in context of CANSCROLLBACKWARDS and CANFETCHBACKWARDS
//
class Scroll_and_Fetch : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Scroll_and_Fetch,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET and no hrows.
int Variation_1();
// @cmember pBookMark=DBBMK_FIRST,cRows=2 Match 3rd row. Verify S_OK and hrows
int Variation_2();
// @cmember pBookMark=DBBMK_LAST,cRows=-2. Match 3rd row. Verify S_OK and 3rd and 2nd hrows
int Variation_3();
// @cmember pBookMark=DBBMK_LAST,cRows=-# rows. Match last row. Verify DB_S_ENDOFROWSET and all rows
int Variation_4();
// @cmember pBookMark=DBBMK_FIRST, cRows=-1. Match first row. Verify S_OK and one row handle.
int Variation_5();
// @cmember pBookMark=DBBMK_FIRST,cRows=1. Match last row. FindNext, cRows=1, Offset=1 and match last. then cRows=-3, match 4th
int Variation_6();
// @cmember pBookmark=DBBMK_LAST,cRows=1. Match last row. Call FindNext, cRows=-3, pBookmark=NULL. Match 4th row, S_OK.
int Variation_7();
// @cmember *pBookmark=DBBMK_LAST, Offset=-2, cRows=-3. Verify row starting with N-4 fetched in traversal order
int Variation_8();
// @cmember pBookmark=NULL, Offset=-2, cRows=-1. Verify N-2 row is fetched and fetch position is after N-3 row
int Variation_9();
// @cmember pBookmark=NULL, Offset=-4, cRows=2 and match last. Verify DB_S_END. Again cRows=-1 and no match. Again cRows=1 and match 1st.
int Variation_10();
// @cmember pBookmark=NULL, cRows=3 and match last. DB_S_END. Again with cRows=2, verify DB_S_END.
int Variation_11();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Scroll_and_Fetch)
#define THE_CLASS Scroll_and_Fetch
BEG_TEST_CASE(Scroll_and_Fetch, TCIRowsetFind, L"Test in context of CANSCROLLBACKWARDS and CANFETCHBACKWARDS")
TEST_VARIATION(1, L"pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET and no hrows.")
TEST_VARIATION(2, L"pBookMark=DBBMK_FIRST,cRows=2 Match 3rd row. Verify S_OK and hrows")
TEST_VARIATION(3, L"pBookMark=DBBMK_LAST,cRows=-2. Match 3rd row. Verify S_OK and 3rd and 2nd hrows")
TEST_VARIATION(4, L"pBookMark=DBBMK_LAST,cRows=-# rows. Match last row. Verify DB_S_ENDOFROWSET and all rows")
TEST_VARIATION(5, L"pBookMark=DBBMK_FIRST, cRows=-1. Match first row. Verify S_OK and one row handle.")
TEST_VARIATION(6, L"pBookMark=DBBMK_FIRST,cRows=1. Match last row. FindNext, cRows=1, Offset=1 and match last. then cRows=-3, match 4th")
TEST_VARIATION(7, L"pBookmark=DBBMK_LAST,cRows=1. Match last row. Call FindNext, cRows=-3, pBookmark=NULL. Match 4th row, S_OK.")
TEST_VARIATION(8, L"*pBookmark=DBBMK_LAST, Offset=-2, cRows=-3. Verify row starting with N-4 fetched in traversal order")
TEST_VARIATION(9, L"pBookmark=NULL, Offset=-2, cRows=-1. Verify N-2 row is fetched and fetch position is after N-3 row")
TEST_VARIATION(10, L"pBookmark=NULL, Offset=-4, cRows=2 and match last. Verify DB_S_END. Again cRows=-1 and no match. Again cRows=1 and match 1st.")
TEST_VARIATION(11, L"pBookmark=NULL, cRows=3 and match last. DB_S_END. Again with cRows=2, verify DB_S_END.")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Boundary)
//--------------------------------------------------------------------
// @class Test invalid arguments
//
class Boundary : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Boundary,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember DB_E_BADCHAPTER
int Variation_1();
// @cmember E_INVALIDARG, cbBookmark != 0, pBookmark = NULL
int Variation_2();
// @cmember E_INVALIDARG, pcRowsObtained = NULL
int Variation_3();
// @cmember E_INVALIDARG prghRows = NULL
int Variation_4();
// @cmember DB_E_COMPAREOPS, CompareOp = -1 (<min
int Variation_5();
// @cmember DB_E_BADCOMPAREOP, CompareOp > max
int Variation_6();
// @cmember DB_E_BADCOMPAREOP, unsupported
int Variation_7();
// @cmember DB_E_BADBINDINFO, NULL hAccessor
int Variation_8();
// @cmember DB_E_BADBINDINFO, 2 columns bound
int Variation_9();
// @cmember DB_E_BADBINDINFO, many columns bound
int Variation_10();
// @cmember DB_E_CANTSCROLLBACKWARDS. cRows > 1
int Variation_11();
// @cmember DB_E_CANTSCROLLBACKWARDS
int Variation_12();
// @cmember DB_E_CANTSCROLLBACKWARDS, pBookmark = DBBMK_FIRST
int Variation_13();
// @cmember DB_E_CANTSCROLLBACKWARDS, pBokmark = DBBMK_LAST
int Variation_14();
// @cmember DB_E_CANTFETCHBACKWARDS
int Variation_15();
// @cmember DB_E_BADCOMPAREOP, IGNORE and CASESENSITIVE
int Variation_16();
// @cmember DB_E_BADCOMPAREOP, just CASESENSITIVE
int Variation_17();
// @cmember DB_E_BADCOMPAREOP, just caseinsensitive
int Variation_18();
// @cmember DB_E_BADCOMPAREOP, both case sensitive and insensitive
int Variation_19();
// @cmember DB_S_ENDOFROWSET, search for null on non-nullable column
int Variation_20();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Boundary)
#define THE_CLASS Boundary
BEG_TEST_CASE(Boundary, TCIRowsetFind, L"Test invalid arguments")
TEST_VARIATION(1, L"DB_E_BADCHAPTER")
TEST_VARIATION(2, L"E_INVALIDARG, cbBookmark != 0, pBookmark = NULL")
TEST_VARIATION(3, L"E_INVALIDARG, pcRowsObtained = NULL")
TEST_VARIATION(4, L"E_INVALIDARG prghRows = NULL")
TEST_VARIATION(5, L"DB_E_COMPAREOPS, CompareOp = -1 (<min")
TEST_VARIATION(6, L"DB_E_BADCOMPAREOP, CompareOp > max")
TEST_VARIATION(7, L"DB_E_BADCOMPAREOP, unsupported")
TEST_VARIATION(8, L"DB_E_BADBINDINFO, NULL hAccessor")
TEST_VARIATION(9, L"DB_E_BADBINDINFO, 2 columns bound")
TEST_VARIATION(10, L"DB_E_BADBINDINFO, many columns bound")
TEST_VARIATION(11, L"DB_E_CANTSCROLLBACKWARDS. cRows > 1")
TEST_VARIATION(12, L"DB_E_CANTSCROLLBACKWARDS")
TEST_VARIATION(13, L"DB_E_CANTSCROLLBACKWARDS, pBookmark = DBBMK_FIRST")
TEST_VARIATION(14, L"DB_E_CANTSCROLLBACKWARDS, pBokmark = DBBMK_LAST")
TEST_VARIATION(15, L"DB_E_CANTFETCHBACKWARDS")
TEST_VARIATION(16, L"DB_E_BADCOMPAREOP, IGNORE and CASESENSITIVE")
TEST_VARIATION(17, L"DB_E_BADCOMPAREOP, just CASESENSITIVE")
TEST_VARIATION(18, L"DB_E_BADCOMPAREOP, just caseinsensitive")
TEST_VARIATION(19, L"DB_E_BADCOMPAREOP, both case sensitive and insensitive")
TEST_VARIATION(20, L"DB_S_ENDOFROWSET, search for null on non-nullable column")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(OutputRowHandleAllocation)
//--------------------------------------------------------------------
// @class Test cRows, prghRows, pcRowsObtained parameters
//
class OutputRowHandleAllocation : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(OutputRowHandleAllocation,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember cRows==0, *prghRows != NULL, Verify *prghRows != NULL on output
int Variation_1();
// @cmember *pcRowsObtained = 0, *prghRows = NULL. Verify *prghRows = NULL on output
int Variation_2();
// @cmember pBookmark=NULL, cRows=0, Match last. Verify S_OK. Set fSkip=1, cRows = 1, pBookmark = NULL, match last. DB_S_ENDOFROWSET
int Variation_3();
// @cmember pBookmark=NULL, cRows=LONG_MAX. fSkip=0. Match first row. Verify DB_S_ENDOFROWSET and all rows in rowset
int Variation_4();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(OutputRowHandleAllocation)
#define THE_CLASS OutputRowHandleAllocation
BEG_TEST_CASE(OutputRowHandleAllocation, TCIRowsetFind, L"Test cRows, prghRows, pcRowsObtained parameters")
TEST_VARIATION(1, L"cRows==0, *prghRows != NULL, Verify *prghRows != NULL on output")
TEST_VARIATION(2, L"*pcRowsObtained = 0, *prghRows = NULL. Verify *prghRows = NULL on output")
TEST_VARIATION(3, L"pBookmark=NULL, cRows=0, Match last. Verify S_OK. Set fSkip=1, cRows = 1, pBookmark = NULL, match last. DB_S_ENDOFROWSET")
TEST_VARIATION(4, L"pBookmark=NULL, cRows=LONG_MAX. fSkip=0. Match first row. Verify DB_S_ENDOFROWSET and all rows in rowset")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(CompareOp)
//--------------------------------------------------------------------
// @class Test the various compare operations
//
class CompareOp : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(CompareOp,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember COMPAREOPS_EQ
int Variation_1();
// @cmember COMPAREOPS_LT
int Variation_2();
// @cmember COMPAREOPS_LE, Use Equal case
int Variation_3();
// @cmember COMPAREOPS_LE, Use Less Than case
int Variation_4();
// @cmember COMPAREOPS_GT
int Variation_5();
// @cmember COMPAREOPS_GE, Use Equal case
int Variation_6();
// @cmember COMPAREOPS_GE, Use Greater than case
int Variation_7();
// @cmember COMPAREOPS_BEGINSWITH
int Variation_8();
// @cmember COMPAREOPS_CONTAINS, match start of string
int Variation_9();
// @cmember COMPAREOPS_CONTAINS, match middle of string
int Variation_10();
// @cmember COMPAREOPS_CONTAINS, match end of string
int Variation_11();
// @cmember COMPAREOPS_NE
int Variation_12();
// @cmember COMPAREOPS_IGNORE
int Variation_13();
// @cmember COMPAREOPS_NOTBEGINSWITH
int Variation_14();
// @cmember COMPAREOPS_NOTCONTAINS
int Variation_15();
// @cmember COMPAREOPS_CONTAINS, use Equal case
int Variation_16();
// @cmember COMPAREOPS_BEGINSWITH, Use Equal case
int Variation_17();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(CompareOp)
#define THE_CLASS CompareOp
BEG_TEST_CASE(CompareOp, TCIRowsetFind, L"Test the various compare operations")
TEST_VARIATION(1, L"COMPAREOPS_EQ")
TEST_VARIATION(2, L"COMPAREOPS_LT")
TEST_VARIATION(3, L"COMPAREOPS_LE, Use Equal case")
TEST_VARIATION(4, L"COMPAREOPS_LE, Use Less Than case")
TEST_VARIATION(5, L"COMPAREOPS_GT")
TEST_VARIATION(6, L"COMPAREOPS_GE, Use Equal case")
TEST_VARIATION(7, L"COMPAREOPS_GE, Use Greater than case")
TEST_VARIATION(8, L"COMPAREOPS_BEGINSWITH")
TEST_VARIATION(9, L"COMPAREOPS_CONTAINS, match start of string")
TEST_VARIATION(10, L"COMPAREOPS_CONTAINS, match middle of string")
TEST_VARIATION(11, L"COMPAREOPS_CONTAINS, match end of string")
TEST_VARIATION(12, L"COMPAREOPS_NE")
TEST_VARIATION(13, L"COMPAREOPS_IGNORE")
TEST_VARIATION(14, L"COMPAREOPS_NOTBEGINSWITH")
TEST_VARIATION(15, L"COMPAREOPS_NOTCONTAINS")
TEST_VARIATION(16, L"COMPAREOPS_CONTAINS, use Equal case")
TEST_VARIATION(17, L"COMPAREOPS_BEGINSWITH, Use Equal case")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(fSkipCurrent)
//--------------------------------------------------------------------
// @class Test for correct behavior with fSkipCurrent flag
//
class fSkipCurrent : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(fSkipCurrent,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember fSkip=0, cRows=1. Match 1st. Verify S_OK and one row handle
int Variation_1();
// @cmember Match 1st row. pBookMark=NULL, fSkip=TRUE. Match 1st row. DB_S_ENDOFROWSET and no row handles.
int Variation_2();
// @cmember Match 5th row. pBookMark=NULL, fSkip=FALSE. Match 5th row. S_OK and no row handles.
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(fSkipCurrent)
#define THE_CLASS fSkipCurrent
BEG_TEST_CASE(fSkipCurrent, TCIRowsetFind, L"Test for correct behavior with fSkipCurrent flag")
TEST_VARIATION(1, L"fSkip=0, cRows=1. Match 1st. Verify S_OK and one row handle")
TEST_VARIATION(2, L"Match 1st row. pBookMark=NULL, fSkip=TRUE. Match 1st row. DB_S_ENDOFROWSET and no row handles.")
TEST_VARIATION(3, L"Match 5th row. pBookMark=NULL, fSkip=FALSE. Match 5th row. S_OK and no row handles.")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(pFindValue)
//--------------------------------------------------------------------
// @class Test the various coercions possible
//
class pFindValue : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(pFindValue,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember IStorage compares, DBCOMPAREOPS_EQ
int Variation_1();
// @cmember IStorage, DBCOMPAREOPS_BEGINSWITH
int Variation_2();
// @cmember IStorage, DBCOMPAREOPS_GT
int Variation_3();
// @cmember IStorage, DBCOMPAREOPS_GE (EQUAL
int Variation_4();
// @cmember IStorage, DBCOMPAREOPS_GE (Greater
int Variation_5();
// @cmember IStorage, DBCOMPAREOPS_LT
int Variation_6();
// @cmember IStorage, DBCOMPAREOPS_LE (EQUAL
int Variation_7();
// @cmember IStorage, DBCOMPAREOPS_LE (Less
int Variation_8();
// @cmember IStorage, DBCOMPAREOPS_CONTAINS, beginning
int Variation_9();
// @cmember IStorage, DBCOMPAREOPS_CONTAINS, middle
int Variation_10();
// @cmember IStorage, DBCOMPAREOPS_CONTAINS, end
int Variation_11();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(pFindValue)
#define THE_CLASS pFindValue
BEG_TEST_CASE(pFindValue, TCIRowsetFind, L"Test the various coercions possible")
TEST_VARIATION(1, L"IStorage compares, DBCOMPAREOPS_EQ")
TEST_VARIATION(2, L"IStorage, DBCOMPAREOPS_BEGINSWITH")
TEST_VARIATION(3, L"IStorage, DBCOMPAREOPS_GT")
TEST_VARIATION(4, L"IStorage, DBCOMPAREOPS_GE (EQUAL")
TEST_VARIATION(5, L"IStorage, DBCOMPAREOPS_GE (Greater")
TEST_VARIATION(6, L"IStorage, DBCOMPAREOPS_LT")
TEST_VARIATION(7, L"IStorage, DBCOMPAREOPS_LE (EQUAL")
TEST_VARIATION(8, L"IStorage, DBCOMPAREOPS_LE (Less")
TEST_VARIATION(9, L"IStorage, DBCOMPAREOPS_CONTAINS, beginning")
TEST_VARIATION(10, L"IStorage, DBCOMPAREOPS_CONTAINS, middle")
TEST_VARIATION(11, L"IStorage, DBCOMPAREOPS_CONTAINS, end")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(SingleRowRowset)
//--------------------------------------------------------------------
// @class Test on a one row rowset
//
class SingleRowRowset : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(SingleRowRowset,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkip=TRUE. DB_S_ENDOFROWSET
int Variation_1();
// @cmember Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkipCurrent = FALSE. S_OK and one row.
int Variation_2();
// @cmember Match First. pBookmark = DBBMK_LAST. cRows=-1, fSkip=TRUE. DB_S_ENDOFROWSET
int Variation_3();
// @cmember Match first. pBookMark=DBBMK_LAST. cRows=-1. fSkip=-1. fSkip=FALSE. S_OK and 1 hrow
int Variation_4();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(SingleRowRowset)
#define THE_CLASS SingleRowRowset
BEG_TEST_CASE(SingleRowRowset, TCIRowsetFind, L"Test on a one row rowset")
TEST_VARIATION(1, L"Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkip=TRUE. DB_S_ENDOFROWSET")
TEST_VARIATION(2, L"Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkipCurrent = FALSE. S_OK and one row.")
TEST_VARIATION(3, L"Match First. pBookmark = DBBMK_LAST. cRows=-1, fSkip=TRUE. DB_S_ENDOFROWSET")
TEST_VARIATION(4, L"Match first. pBookMark=DBBMK_LAST. cRows=-1. fSkip=-1. fSkip=FALSE. S_OK and 1 hrow")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Related_RestartPosition)
//--------------------------------------------------------------------
// @class Test in conjunction with RestartPosition
//
class Related_RestartPosition : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Related_RestartPosition,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Match 5th. Restart. Call Find, cRows=1, fSkip=TRUE, match 5th. Verify DB_S_ENDOFROWSET (because of restart
int Variation_1();
// @cmember Match 5th. Restart. Call Find, cRows=1, fSkip=FALSE, match 4th. Verify DB_S_ENDOFROWSET
int Variation_2();
// @cmember Match Last. Restart. Call Find, cRows=1, fSkip=TRUE. Verify DB_S_ENDOFROWSET
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Related_RestartPosition)
#define THE_CLASS Related_RestartPosition
BEG_TEST_CASE(Related_RestartPosition, TCIRowsetFind, L"Test in conjunction with RestartPosition")
TEST_VARIATION(1, L"Match 5th. Restart. Call Find, cRows=1, fSkip=TRUE, match 5th. Verify DB_S_ENDOFROWSET (because of restart")
TEST_VARIATION(2, L"Match 5th. Restart. Call Find, cRows=1, fSkip=FALSE, match 4th. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(3, L"Match Last. Restart. Call Find, cRows=1, fSkip=TRUE. Verify DB_S_ENDOFROWSET")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Related_GetNextRows)
//--------------------------------------------------------------------
// @class Test in conjunction with GetNextRows
//
class Related_GetNextRows : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Related_GetNextRows,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookmark=DBBMK_FIRST, Verify GetNextRows pos not changed
int Variation_1();
// @cmember Use pBookmark=middle bmk. Verify GetNextRows pos not changed
int Variation_2();
// @cmember Use pBookMark = DBBMK_LAST, Verify GetNextRows pos not changed
int Variation_3();
// @cmember use pBookmark=NULL, match 1st row. Verify GetNextRows pos is after 1st row.
int Variation_4();
// @cmember Use pBookmark=NULL, match last row. Verify GetNextRows with cRows=1 returns DB_S_ENDOFROWSET
int Variation_5();
// @cmember Use pBookmark=NULL, match middle row. Use pBookmark=2nd bmk and match 2nd. Verify GetNextRows is still after middle row
int Variation_6();
// @cmember Call GetNextRows with last row fetched = 3. Call FindNextRows, pBookmark=NULL,cRows=-1 to match 4th. Verify DB_S_ENDOFROWSET
int Variation_7();
// @cmember GetNextRows, cRows=1, Offset=0. Verify S_OK. FindNext with pBookmark=NULL, cRows=1 and match 1st. Verify DB_S_ENDOFROWSET
int Variation_8();
// @cmember FindNext with pBookmark=NULL, cRows=2 and match 4th. GetNextRows with cRows=-3. Verify 5,4,3 row handles.
int Variation_9();
// @cmember FindNext, pBookmark=NULL, match last. FindNext, pBmk=NULL, cRows=-1, match last. GetNext. cRows=-1 and verify next to last
int Variation_10();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Related_GetNextRows)
#define THE_CLASS Related_GetNextRows
BEG_TEST_CASE(Related_GetNextRows, TCIRowsetFind, L"Test in conjunction with GetNextRows")
TEST_VARIATION(1, L"pBookmark=DBBMK_FIRST, Verify GetNextRows pos not changed")
TEST_VARIATION(2, L"Use pBookmark=middle bmk. Verify GetNextRows pos not changed")
TEST_VARIATION(3, L"Use pBookMark = DBBMK_LAST, Verify GetNextRows pos not changed")
TEST_VARIATION(4, L"use pBookmark=NULL, match 1st row. Verify GetNextRows pos is after 1st row.")
TEST_VARIATION(5, L"Use pBookmark=NULL, match last row. Verify GetNextRows with cRows=1 returns DB_S_ENDOFROWSET")
TEST_VARIATION(6, L"Use pBookmark=NULL, match middle row. Use pBookmark=2nd bmk and match 2nd. Verify GetNextRows is still after middle row")
TEST_VARIATION(7, L"Call GetNextRows with last row fetched = 3. Call FindNextRows, pBookmark=NULL,cRows=-1 to match 4th. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(8, L"GetNextRows, cRows=1, Offset=0. Verify S_OK. FindNext with pBookmark=NULL, cRows=1 and match 1st. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(9, L"FindNext with pBookmark=NULL, cRows=2 and match 4th. GetNextRows with cRows=-3. Verify 5,4,3 row handles.")
TEST_VARIATION(10, L"FindNext, pBookmark=NULL, match last. FindNext, pBmk=NULL, cRows=-1, match last. GetNext. cRows=-1 and verify next to last")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Scroll_BookMark)
//--------------------------------------------------------------------
// @class CanScrollBackwards with bookmarks
//
class Scroll_BookMark : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Scroll_BookMark,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookMark=DBBMK_FIRST, cRows=1. Match first row. Verify S_OK and one row handle
int Variation_1();
// @cmember pBookMark=DBBMK_LAST,cRows=1. Match last row. Verify S_OK and last row
int Variation_2();
// @cmember pBookMark=DBBMK_INVALID. Verify DB_E_BADBOOKMARK
int Variation_3();
// @cmember pBookMark=one bookmark for each row, cRows=1. Always match current row.
int Variation_4();
// @cmember pBookmark=random value. Verify DB_E_BADBOOKMARK (warning-could get a provider specific error
int Variation_5();
// @cmember *pBookmark=2nd row and offset=-1, cRows=1. Verify first row matched.
int Variation_6();
// @cmember *pBookmark=4th row, Offset=2, cRows=1 and match 5th row. Verify DB_S_ENDOFROWSET
int Variation_7();
// @cmember *pBookmark=5th row. Offset=0, cRows=1 and match 5th. Again with pBookmark=NULL, Offset=0, cRows=1 and match 2nd. Verify S_OK
int Variation_8();
// @cmember *pBookmark=2nd row and offset = -2, cRows=1, Verify DB_S_ENDOFROWSET
int Variation_9();
// @cmember pBookmark=DBBMK_FIRST, cRows=0 Should be no-op
int Variation_10();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Scroll_BookMark)
#define THE_CLASS Scroll_BookMark
BEG_TEST_CASE(Scroll_BookMark, TCIRowsetFind, L"CanScrollBackwards with bookmarks")
TEST_VARIATION(1, L"pBookMark=DBBMK_FIRST, cRows=1. Match first row. Verify S_OK and one row handle")
TEST_VARIATION(2, L"pBookMark=DBBMK_LAST,cRows=1. Match last row. Verify S_OK and last row")
TEST_VARIATION(3, L"pBookMark=DBBMK_INVALID. Verify DB_E_BADBOOKMARK")
TEST_VARIATION(4, L"pBookMark=one bookmark for each row, cRows=1. Always match current row.")
TEST_VARIATION(5, L"pBookmark=random value. Verify DB_E_BADBOOKMARK (warning-could get a provider specific error")
TEST_VARIATION(6, L"*pBookmark=2nd row and offset=-1, cRows=1. Verify first row matched.")
TEST_VARIATION(7, L"*pBookmark=4th row, Offset=2, cRows=1 and match 5th row. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(8, L"*pBookmark=5th row. Offset=0, cRows=1 and match 5th. Again with pBookmark=NULL, Offset=0, cRows=1 and match 2nd. Verify S_OK")
TEST_VARIATION(9, L"*pBookmark=2nd row and offset = -2, cRows=1, Verify DB_S_ENDOFROWSET")
TEST_VARIATION(10, L"pBookmark=DBBMK_FIRST, cRows=0 Should be no-op")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Scroll_Fetch_Bookmarks)
//--------------------------------------------------------------------
// @class CanScrollBackwards and CanFetchBackwards with Bookmarks
//
class Scroll_Fetch_Bookmarks : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Scroll_Fetch_Bookmarks,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookMark=DBBMK_FIRST, cRows=5 and match 1st row. Verify S_OK and 5 hrows
int Variation_1();
// @cmember pBookMarks=DBBMK_LAST,cRows=-5 match last row. Verify S_OK and 5 hrows
int Variation_2();
// @cmember pBookmark=2nd row, cRows=2, Offset=1. Match 4th row. Verify S_OK and 2 hrows
int Variation_3();
// @cmember pBookMark=5th row, cRows=-2. Match3rd row. Verify S_OK and 2 hrows
int Variation_4();
// @cmember pBookmark=Last row, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET
int Variation_5();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Scroll_Fetch_Bookmarks)
#define THE_CLASS Scroll_Fetch_Bookmarks
BEG_TEST_CASE(Scroll_Fetch_Bookmarks, TCIRowsetFind, L"CanScrollBackwards and CanFetchBackwards with Bookmarks")
TEST_VARIATION(1, L"pBookMark=DBBMK_FIRST, cRows=5 and match 1st row. Verify S_OK and 5 hrows")
TEST_VARIATION(2, L"pBookMarks=DBBMK_LAST,cRows=-5 match last row. Verify S_OK and 5 hrows")
TEST_VARIATION(3, L"pBookmark=2nd row, cRows=2, Offset=1. Match 4th row. Verify S_OK and 2 hrows")
TEST_VARIATION(4, L"pBookMark=5th row, cRows=-2. Match3rd row. Verify S_OK and 2 hrows")
TEST_VARIATION(5, L"pBookmark=Last row, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(CaseSensitive_Compares)
//--------------------------------------------------------------------
// @class Test the case sensitive property
//
class CaseSensitive_Compares : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(CaseSensitive_Compares,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember EQ, sensitive
int Variation_1();
// @cmember EQ, insensitive
int Variation_2();
// @cmember LT, sensitive
int Variation_3();
// @cmember LT, insensitve
int Variation_4();
// @cmember LE, sensitive
int Variation_5();
// @cmember LE, insensitive
int Variation_6();
// @cmember GT, sensitive
int Variation_7();
// @cmember GT, insensitive
int Variation_8();
// @cmember GE, sensitive
int Variation_9();
// @cmember GE, insensitve
int Variation_10();
// @cmember NE, sensitive
int Variation_11();
// @cmember NE, insensitive
int Variation_12();
// @cmember BEGINSWITH, sensitve
int Variation_13();
// @cmember BEGINSWITH, insensitive
int Variation_14();
// @cmember BEGINSWITH, sensitive negative match
int Variation_15();
// @cmember CONTAINS, sensitive
int Variation_16();
// @cmember CONTAINS, insensitive
int Variation_17();
// @cmember CONTAINS, sensitive negative match
int Variation_18();
// @cmember NOTBEGINSWITH, sensitive
int Variation_19();
// @cmember NOTBEGINSWITH, insensitive
int Variation_20();
// @cmember NOTBEGINSWITH, sensitive negative match
int Variation_21();
// @cmember NOTCONTAINS, sensitive
int Variation_22();
// @cmember NOCONTAINS, insensitive
int Variation_23();
// @cmember NOCONTAINS, sensitive negative match
int Variation_24();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(CaseSensitive_Compares)
#define THE_CLASS CaseSensitive_Compares
BEG_TEST_CASE(CaseSensitive_Compares, TCIRowsetFind, L"Test the case sensitive property")
TEST_VARIATION(1, L"EQ, sensitive")
TEST_VARIATION(2, L"EQ, insensitive")
TEST_VARIATION(3, L"LT, sensitive")
TEST_VARIATION(4, L"LT, insensitve")
TEST_VARIATION(5, L"LE, sensitive")
TEST_VARIATION(6, L"LE, insensitive")
TEST_VARIATION(7, L"GT, sensitive")
TEST_VARIATION(8, L"GT, insensitive")
TEST_VARIATION(9, L"GE, sensitive")
TEST_VARIATION(10, L"GE, insensitve")
TEST_VARIATION(11, L"NE, sensitive")
TEST_VARIATION(12, L"NE, insensitive")
TEST_VARIATION(13, L"BEGINSWITH, sensitve")
TEST_VARIATION(14, L"BEGINSWITH, insensitive")
TEST_VARIATION(15, L"BEGINSWITH, sensitive negative match")
TEST_VARIATION(16, L"CONTAINS, sensitive")
TEST_VARIATION(17, L"CONTAINS, insensitive")
TEST_VARIATION(18, L"CONTAINS, sensitive negative match")
TEST_VARIATION(19, L"NOTBEGINSWITH, sensitive")
TEST_VARIATION(20, L"NOTBEGINSWITH, insensitive")
TEST_VARIATION(21, L"NOTBEGINSWITH, sensitive negative match")
TEST_VARIATION(22, L"NOTCONTAINS, sensitive")
TEST_VARIATION(23, L"NOCONTAINS, insensitive")
TEST_VARIATION(24, L"NOCONTAINS, sensitive negative match")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Scroll_Fetch_Hold)
//--------------------------------------------------------------------
// @class Test with CanScrollBack, CanFetchBack, and CanHoldRows
//
class Scroll_Fetch_Hold : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Scroll_Fetch_Hold,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookmark=2nd row, cRows=-1. Verify S_OK and one row handle
int Variation_1();
// @cmember pBookmark=3rd row. cRows=3. Match 3rd row. Do not release. pBookmark=4th row, cRows=2, match 4th. Release 1st 3, ver last 2
int Variation_2();
// @cmember pBookmark=5th,cRows=-5, match 5th. S_OK,5 hrows. pBookmark=4th,cRows=-5. DB_S_ENDOFROWSET and 4 hrows. Release last 4, check 5
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Scroll_Fetch_Hold)
#define THE_CLASS Scroll_Fetch_Hold
BEG_TEST_CASE(Scroll_Fetch_Hold, TCIRowsetFind, L"Test with CanScrollBack, CanFetchBack, and CanHoldRows")
TEST_VARIATION(1, L"pBookmark=2nd row, cRows=-1. Verify S_OK and one row handle")
TEST_VARIATION(2, L"pBookmark=3rd row. cRows=3. Match 3rd row. Do not release. pBookmark=4th row, cRows=2, match 4th. Release 1st 3, ver last 2")
TEST_VARIATION(3, L"pBookmark=5th,cRows=-5, match 5th. S_OK,5 hrows. pBookmark=4th,cRows=-5. DB_S_ENDOFROWSET and 4 hrows. Release last 4, check 5")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Dynamic)
//--------------------------------------------------------------------
// @class Test with OTHERINSERT and OTHERUPDATE properties
//
class Dynamic : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Dynamic,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Insert a new row at end. pBookmark=NULL,cRows=1. Match new row. Verify S_OK and one row handle
int Variation_1();
// @cmember Insert a new row at the end. pBookmark=DBBMK_LAST,cRows=1. DBCOMPAREOPS_IGNORE. Verify S_OK and new row matched.
int Variation_2();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Dynamic)
#define THE_CLASS Dynamic
BEG_TEST_CASE(Dynamic, TCIRowsetFind, L"Test with OTHERINSERT and OTHERUPDATE properties")
TEST_VARIATION(1, L"Insert a new row at end. pBookmark=NULL,cRows=1. Match new row. Verify S_OK and one row handle")
TEST_VARIATION(2, L"Insert a new row at the end. pBookmark=DBBMK_LAST,cRows=1. DBCOMPAREOPS_IGNORE. Verify S_OK and new row matched.")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(MaxRows)
//--------------------------------------------------------------------
// @class Test MaxRows property
//
class MaxRows : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(MaxRows,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Set MAXROWS=3. pBookmark=2nd row. cRows=4. Match 3rd row. DB_S_ENDOFROWSET and 3 hrows
int Variation_1();
// @cmember Set MAXROWS=2. pBookmark=3rd row,cRows=3. Match 3rd row. DB_S_ROWLIMITEXECEEDED and 2 hrows
int Variation_2();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(MaxRows)
#define THE_CLASS MaxRows
BEG_TEST_CASE(MaxRows, TCIRowsetFind, L"Test MaxRows property")
TEST_VARIATION(1, L"Set MAXROWS=3. pBookmark=2nd row. cRows=4. Match 3rd row. DB_S_ENDOFROWSET and 3 hrows")
TEST_VARIATION(2, L"Set MAXROWS=2. pBookmark=3rd row,cRows=3. Match 3rd row. DB_S_ROWLIMITEXECEEDED and 2 hrows")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(EmptyRowset)
//--------------------------------------------------------------------
// @class EmptyRowset
//
class EmptyRowset : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(EmptyRowset,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookmark=NULL, cRows=0. DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET
int Variation_1();
// @cmember pBookmark=NULL, cRows=1. DB_S_ENDOFROWSET
int Variation_2();
// @cmember pBookmark=NULL, cRows=-1. DB_S_ENDOFROWSET
int Variation_3();
// @cmember pBookmark=NULL,cRows=0,fSkip=TRUE. Verify DB_S_ENDOFROWSET
int Variation_4();
// @cmember pBookMark=DBBMK_FIRST,cRows=1. Verify DB_S_ENDOFROWSET
int Variation_5();
// @cmember pBookmark=DBBMK_FIRST, cRows=0, DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET
int Variation_6();
// @cmember pBookmark=DBBMK_LAST,cRows=1. Verify DB_S_ENDOFROWSET
int Variation_7();
// @cmember pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET
int Variation_8();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(EmptyRowset)
#define THE_CLASS EmptyRowset
BEG_TEST_CASE(EmptyRowset, TCIRowsetFind, L"EmptyRowset")
TEST_VARIATION(1, L"pBookmark=NULL, cRows=0. DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(2, L"pBookmark=NULL, cRows=1. DB_S_ENDOFROWSET")
TEST_VARIATION(3, L"pBookmark=NULL, cRows=-1. DB_S_ENDOFROWSET")
TEST_VARIATION(4, L"pBookmark=NULL,cRows=0,fSkip=TRUE. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(5, L"pBookMark=DBBMK_FIRST,cRows=1. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(6, L"pBookmark=DBBMK_FIRST, cRows=0, DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(7, L"pBookmark=DBBMK_LAST,cRows=1. Verify DB_S_ENDOFROWSET")
TEST_VARIATION(8, L"pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(NULL_Collation)
//--------------------------------------------------------------------
// @class Test Null collatioans
//
class NULL_Collation : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(NULL_Collation,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember NE operator with NULL status
int Variation_1();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(NULL_Collation)
#define THE_CLASS NULL_Collation
BEG_TEST_CASE(NULL_Collation, TCIRowsetFind, L"Test Null collations")
TEST_VARIATION(1, L"NE operator with NULL status")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Prop_FINDCOMPAREOPS)
//--------------------------------------------------------------------
// @class Check DBPROP_FINDCOMAPREOPS
//
class Prop_FINDCOMPAREOPS : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Prop_FINDCOMPAREOPS,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Check CO_EQUALITY and CO_STRING
int Variation_1();
// @cmember Check Case Sensitivity
int Variation_2();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Prop_FINDCOMPAREOPS)
#define THE_CLASS Prop_FINDCOMPAREOPS
BEG_TEST_CASE(Prop_FINDCOMPAREOPS, TCIRowsetFind, L"Check DBPROP_FINDCOMAPREOPS")
TEST_VARIATION(1, L"Check CO_EQUALITY and CO_STRING")
TEST_VARIATION(2, L"Check Case Sensitivity")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(QueryInt)
//--------------------------------------------------------------------
// @class test queryinterfaces
//
class QueryInt : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(QueryInt,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember IRowset
int Variation_1();
// @cmember IAccessor
int Variation_2();
// @cmember Use ICmdText
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(QueryInt)
#define THE_CLASS QueryInt
BEG_TEST_CASE(QueryInt, TCIRowsetFind, L"test queryinterfaces")
TEST_VARIATION(1, L"IRowset")
TEST_VARIATION(2, L"IAccessor")
TEST_VARIATION(3, L"Use ICmdText")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCCompareOps_Ignore)
//--------------------------------------------------------------------
// @class Test specific IGNORE cases
//
class TCCompareOps_Ignore : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCompareOps_Ignore,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember IGNORE w/pBookmark=NULL
int Variation_1();
// @cmember IGNORE w/ pBookmark = STD_BOOKMARK
int Variation_2();
// @cmember IGNORE w/real bookmark
int Variation_3();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(TCCompareOps_Ignore)
#define THE_CLASS TCCompareOps_Ignore
BEG_TEST_CASE(TCCompareOps_Ignore, TCIRowsetFind, L"Test specific IGNORE cases")
TEST_VARIATION(1, L"IGNORE w/pBookmark=NULL")
TEST_VARIATION(2, L"IGNORE w/ pBookmark = STD_BOOKMARK")
TEST_VARIATION(3, L"IGNORE w/real bookmark")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(AccessorTests)
//--------------------------------------------------------------------
// @class Test various accessor variations
//
class AccessorTests : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(AccessorTests,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember obValue = 0
int Variation_1();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(AccessorTests)
#define THE_CLASS AccessorTests
BEG_TEST_CASE(AccessorTests, TCIRowsetFind, L"Test various accessor variations")
TEST_VARIATION(1, L"obValue = 0")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(BindingType)
//--------------------------------------------------------------------
// @class Test interesting Find coercions
//
class BindingType : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(BindingType,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Normal BSTR
int Variation_1();
// @cmember WSTR
int Variation_2();
// @cmember STR
int Variation_3();
// @cmember VARIANT
int Variation_4();
// @cmember WSTR | BYREF
int Variation_5();
// @cmember STR | BYREF
int Variation_6();
// @cmember BSTR | BYREF
int Variation_7();
// @cmember VARIANT BYREF
int Variation_8();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(BindingType)
#define THE_CLASS BindingType
BEG_TEST_CASE(BindingType, TCIRowsetFind, L"Test interesting Find coercions")
TEST_VARIATION(1, L"Normal BSTR")
TEST_VARIATION(2, L"WSTR")
TEST_VARIATION(3, L"STR")
TEST_VARIATION(4, L"VARIANT")
TEST_VARIATION(5, L"WSTR | BYREF")
TEST_VARIATION(6, L"STR | BYREF")
TEST_VARIATION(7, L"BSTR | BYREF")
TEST_VARIATION(8, L"VARIANT BYREF")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(Deleted_Rows)
//--------------------------------------------------------------------
// @class Test with deleted rows
//
class Deleted_Rows : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(Deleted_Rows,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pBookMark=DBBMK_LAST. Delete last row. Expect DB_E_BADBOOKMARK
int Variation_1();
// @cmember pBookMark = 2, cRows=1. Delete 4th row. Match on what was in 4th row. DB_S_ENDOFROWSET and 0 row
int Variation_2();
// @cmember pBookMark=4, cRows=-1. Delete 1st row. Match on what was in 1st row. DB_S_ENDOFROWSET and 0 row
int Variation_3();
// @cmember pBookMark=NULL,cRows=1 Match 3rd row. Delete third row. pBookmark=NULL, cRows=1, fSkip=0. Match 4th. S_OK, 1 hrow
int Variation_4();
// @cmember pBookmark=NULL, cRows=-2, match 3rd row. Delete 3rd. Match 2nd
int Variation_5();
// @cmember Delete RowLast-1 row. pBookmark=RowLast-2 row,cRows=3. Match RowLast-2 row.
// Verify S_OK, 3 hrows and DB_E_DELETEDROW when accessing deleted one
int Variation_6();
// @cmember Delete last row. pBookmark=DBBMK_LAST, cRows=1. Verify DB_E_BADBOOKMARK, 0 rows returned
int Variation_7();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(Deleted_Rows)
#define THE_CLASS Deleted_Rows
BEG_TEST_CASE(Deleted_Rows, TCIRowsetFind, L"Test with deleted rows")
TEST_VARIATION(1, L"pBookMark=DBBMK_LAST. Delete last row. Expect DB_E_BADBOOKMARK")
TEST_VARIATION(2, L"pBookMark = 2, cRows=1. Delete 4th row. Match on what was in 4th row. DB_S_ENDOFROWSET and 0 row")
TEST_VARIATION(3, L"pBookMark=4, cRows=-1. Delete 1st row. Match on what was in 1st row. DB_S_ENDOFROWSET and 0 row")
TEST_VARIATION(4, L"pBookMark=NULL,cRows=1 Match 3rd row. Delete third row. pBookmark=NULL, cRows=1, fSkip=0. Match 4th. S_OK, 1 hrow")
TEST_VARIATION(5, L"pBookmark=NULL, cRows=-2, match 3rd row. Delete 3rd. Match 2nd")
TEST_VARIATION(6, L"Delete RowLast-1 row.pBookmark=RowLast-2 row, cRows=3.Match RowLast-2 row.Verify DB_S_ENDOFROWSET and return 3 rows")
TEST_VARIATION(7, L"Delete last row. pBookmark=DBBMK_LAST, cRows=1. Verify DB_E_BADBOOKMARK, 0 rows returned")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(RemoveDeleted)
//--------------------------------------------------------------------
// @class Test in context of RemoveDeleted
//
class RemoveDeleted : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(RemoveDeleted,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Delete a row. pBookmark=deleted row. Verify DB_E_BADBOOKMARK.
int Variation_1();
// @cmember Delete 3rd row. pBookmark=2nd row with cRows=3. Verify S_OK and 2,4,5 hrows
int Variation_2();
// @cmember Delete g_lRowLast-1 row. pBookmark=g_lRowLast-2 row,cRows=3. Match g_lRowLast-2 row.
// Verify DB_S_ENDOFROWSET and return RowLast-2, RowLast hrows.
int Variation_3();
// @cmember Delete last row. pBookmark=DBBMK_LAST,cRows=-1. DBCOMPAREOPS_IGNORE.
int Variation_4();
// @cmember pBookmark=NULL, cRows = 2. match 3rd. Delete 2nd and 5th rows. Find with cRows= -1 and match third
int Variation_5();
// @cmember pBookMark=NULL, cRows=1.Delete 4th row.Match on what was in 4th row.DB_S_ENDOFROWSET and 0 rows
int Variation_6();
// @cmember pBookMark=DBBMK_LAST,cRows=-1.Delete 1st row.Match on what was in 1st row.DB_S_ENDOFROWSET and 0 rows
int Variation_7();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(RemoveDeleted)
#define THE_CLASS RemoveDeleted
BEG_TEST_CASE(RemoveDeleted, TCIRowsetFind, L"Test in context of RemoveDeleted")
TEST_VARIATION(1, L"Delete a row. pBookmark=deleted row. Verify DB_E_BADBOOKMARK")
TEST_VARIATION(2, L"Delete 3rd row. pBookmark=2nd row with cRows=3. Verify S_OK and 2,4,5 hrows")
TEST_VARIATION(3, L"Delete Last-1 row.pBookmark=Last-2 row,cRows=3.Match Last-2 row.Verify DB_S_ENDOFROWSET,2 rows")
TEST_VARIATION(4, L"Delete last row. pBookmark=DBBMK_LAST,cRows=-1. ")
TEST_VARIATION(5, L"pBookmark=NULL, cRows = 2. match 3rd. Delete 2nd and 5th rows. Find with cRows= -1")
TEST_VARIATION(6, L"pBookMark =NULL,cRows=1.Delete 4th row.Match on what was in 4th row.DB_S_ENDOFROWSET and 0 rows")
TEST_VARIATION(7, L"pBookMark=DBBMK_LAST,cRows=-1.Delete 1st row.Match on what was in 1st row.DB_S_ENDOFROWSET and 0 rows")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(BookmarkSkipped)
//--------------------------------------------------------------------
// @class Test in the context of DBPROP_BOOKMARKSKIPPED
//
class BookmarkSkipped : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(BookmarkSkipped,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Delete 1st row. pBookmark=1st row,cRows=5. Match 2nd row. DB_S_ENDOFROWSET(overrides S_BOOKMARKSKIPPED
int Variation_1();
// @cmember Delete last row. pBookmark=last row, cRows=1. Match what was in last row. DB_S_BOOKMARKSKIPPED and no rows retrieved.
int Variation_2();
// @cmember Delete the first row. pBookmark=1st row,cRows=1. Match 2nd row. DB_S_BOOKMARKSKIPED and 2nd hrow returned.
int Variation_3();
// @cmember Delete 3rd row. pBookmark=3rd row,cRows=1. Match 5th row. DB_S_BOOKMARKSKIPPED and one hrow.
int Variation_4();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(BookmarkSkipped)
#define THE_CLASS BookmarkSkipped
BEG_TEST_CASE(BookmarkSkipped, TCIRowsetFind, L"Test in the context of DBPROP_BOOKMARKSKIPPED")
TEST_VARIATION(1, L"Delete 1st row. pBookmark=1st row,cRows=5. Match 2nd row. DB_S_ENDOFROWSET(overrides S_BOOKMARKSKIPPED")
TEST_VARIATION(2, L"Delete last row. pBookmark=last row, cRows=1. Match what was in last row. DB_S_BOOKMARKSKIPPED and no rows retrieved.")
TEST_VARIATION(3, L"Delete the first row. pBookmark=1st row,cRows=1. Match 2nd row. DB_S_BOOKMARKSKIPED and 2nd hrow returned.")
TEST_VARIATION(4, L"Delete 3rd row. pBookmark=3rd row,cRows=1. Match 5th row. DB_S_BOOKMARKSKIPPED and one hrow.")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCJapanese)
//*-----------------------------------------------------------------------
// @class Test scenarios relevant to the JPN locale
//
class TCJapanese : public TCIRowsetFind {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCJapanese,TCIRowsetFind);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Test case sensitivity and CONTAINS
int Variation_1();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCJapanese)
#define THE_CLASS TCJapanese
BEG_TEST_CASE(TCJapanese, TCIRowsetFind, L"Test scenarios relevant to the JPN locale")
TEST_VARIATION(1, L"Test case sensitivity and CONTAINS")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(30, ThisModule, gwszModuleDescrip)
TEST_CASE(1, No_Properties)
TEST_CASE(2, FetchBackwards)
TEST_CASE(3, ScrollBackwards)
TEST_CASE(4, CanHoldRows)
TEST_CASE(5, Scroll_and_Fetch)
TEST_CASE(6, Boundary)
TEST_CASE(7, OutputRowHandleAllocation)
TEST_CASE(8, CompareOp)
TEST_CASE(9, fSkipCurrent)
TEST_CASE(10, pFindValue)
TEST_CASE(11, SingleRowRowset)
TEST_CASE(12, Related_RestartPosition)
TEST_CASE(13, Related_GetNextRows)
TEST_CASE(14, Scroll_BookMark)
TEST_CASE(15, Scroll_Fetch_Bookmarks)
TEST_CASE(16, CaseSensitive_Compares)
TEST_CASE(17, Scroll_Fetch_Hold)
TEST_CASE(18, Dynamic)
TEST_CASE(19, MaxRows)
TEST_CASE(20, EmptyRowset)
TEST_CASE(21, NULL_Collation)
TEST_CASE(22, Prop_FINDCOMPAREOPS)
TEST_CASE(23, QueryInt)
TEST_CASE(24, TCCompareOps_Ignore)
TEST_CASE(25, AccessorTests)
TEST_CASE(26, BindingType)
TEST_CASE(27, Deleted_Rows)
TEST_CASE(28, RemoveDeleted)
TEST_CASE(29, BookmarkSkipped)
TEST_CASE(30, TCJapanese)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
// {{ TCW_TC_PROTOTYPE(No_Properties)
//*-----------------------------------------------------------------------
//| Test Case: No_Properties - no properties set
//| Created: 06/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL No_Properties::Init()
{
DBPROPID guidPropertySet;
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidPropertySet));
CLEANUP:
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL,cRows=1,fSkip=1. Traverse rowset by matching current row until DB_S_ENDOF_ROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int No_Properties::Variation_1()
{
BOOL fTestPass = TEST_PASS;
for ( LONG i = 1; i <= (g_lRowLast+1); i++ )
{
fTestPass =
CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
i, // row to match
( i <= g_lRowLast ? S_OK : DB_S_ENDOFROWSET ), // HRESULT to verify
( i <= g_lRowLast ? 1 : 0 ) // How many rows to expect.
);
if ( fTestPass == TEST_FAIL )
break;
}
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, match middle. Again, pBookmark=NULL, cRows=1 and Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int No_Properties::Variation_2()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast/2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast/2, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
CLEANUP:
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, and match 2nd. Again pBookmark=NULL, cRows=3, match 4th. S_OK and 3 row handles
//
// @rdesc TEST_PASS or TEST_FAIL
//
int No_Properties::Variation_3()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
3 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
CLEANUP:
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL No_Properties::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(FetchBackwards)
//*-----------------------------------------------------------------------
//| Test Case: FetchBackwards - Test FetchBackwards property
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL FetchBackwards::Init()
{
DBPROPID guidProperty;
ULONG cPrptSet = 0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported);
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidProperty=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
//create a rowset and accessor
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=NULL,cRows=1 and match 1st row. FindNext, cRows=-1 matching same row. Verify S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_1()
{
BOOL fTestPass=TEST_FAIL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass,TRUE ) )
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=NULL, cRows=3 and Match 1st row. FindNext, cRows=-2 and match 3rd row. Verify S_OK and 3rd and 2nd rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_2()
{
BOOL fTestPass = FALSE;
BYTE *pBookmark=NULL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
3 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
-2, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL,cRows=1 nd match last row. FindNext wiht cRows=-2,fSkip=0 and match 3rd row. Verify S_OK and hrows.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_3()
{
BOOL fTestPass = FALSE;
BYTE *pBookmark=NULL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
-2, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=NULL,cRows=1 and match last row. FindNext, cRows=-6, match last row. Verify DB_S_ENDOFROWSET and hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_4()
{
BOOL fTestPass = FALSE;
BYTE *pBookmark=NULL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
0, // Length of bookmark
-(g_lRowLast+1), // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
g_lRowLast // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, and match last. pBookmark=NULL, cRows=3. Offset=1 and mattch 2nd row. Verify DB_S_ENDOFROWSET.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_5()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-3, // # rows to fetch
1, // offset
g_ulColNum, // Which column to match
2, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
2 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1 and match last. Loop with cRows=-1 until DB_S_ENDOFROWSET.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_6()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
for ( DBROWCOUNT i=g_lRowLast; i>=0 ; i-- )
{
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // lOffset
g_ulColNum, // Which column to match
i, // row to match
(i==0 ? DB_S_ENDOFROWSET : S_OK ), // HRESULT to verify
(i==0 ? 0 : 1) // How many rows to expect.
);
if (!COMPARE(fTestPass, TEST_PASS))
return TEST_FAIL;
}
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, Match next to last. FindNext with cRows=-1 and Offset=2. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_7()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
2, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Test that cRows=0 doesn't affect find direction
//
// @rdesc TEST_PASS or TEST_FAIL
//
int FetchBackwards::Variation_8()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
0, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
S_OK, // HRESULT to verify
0 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
//cursor is now after g_lRowLast-1
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast-2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL FetchBackwards::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(ScrollBackwards)
//*-----------------------------------------------------------------------
//| Test Case: ScrollBackwards - Test ScrollBackwards property
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ScrollBackwards::Init()
{
DBPROPID guidPropertySet[1];
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet[cPrptSet++]=DBPROP_CANSCROLLBACKWARDS;
}
//create a rowset and an accessor.
//DBPROP_CANSCROLLBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST,cRows=1 and match 2nd row. Verify S_OK and one row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_1()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_LAST,cRows=1 and Match last row. Verify S_OK and one row handle.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_2()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_LAST, cRows=1, and match last. Verify S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_3()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
1, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=DBBMK_FIRST, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_4()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
g_lRowLast, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, and match middle. FindNext with Offset=-3, cRows=3 and match row preceding middle row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_5()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast/2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
3, // # rows to fetch
-3, // offset
g_ulColNum, // Which column to match
(g_lRowLast/2)-1, // row to match
S_OK, // HRESULT to verify
3 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, and match last. FindNext with cRows=1, Offset=-1 and match last. Verify S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_6()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
-1, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, Loffset=-# of rows. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_7()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
-g_lRowLast, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL,cRows=1, Offset=-2. Verify #of rows-1 row fetched. Cursor is after next to last row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_8()
{
BOOL fTestPass;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
-2, // offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1, Loffset=-#of rows+1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ScrollBackwards::Variation_9()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
-(g_lRowLast+1), // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL ScrollBackwards::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(CanHoldRows)
//*-----------------------------------------------------------------------
//| Test Case: CanHoldRows - Test DBPROP can hold row property
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL CanHoldRows::Init()
{
DBPROPID guidProperty;
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_CanHoldRows].fSupported);
if(!g_rgDBPrpt[IDX_CanHoldRows].fDefault)
{
guidProperty=DBPROP_CANHOLDROWS;
cPrptSet++;
}
//create a rowset and accessor
//DBPROP_CANHOLDROWS
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Get 1,2 row. Get 2,3,4 rows. S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CanHoldRows::Variation_1()
{
HROW *phRows1, *phRows2;
BOOL fTestPass = TRUE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
phRows1 = (HROW *) PROVIDER_ALLOC( 2 * sizeof(HROW) );
phRows2 = (HROW *) PROVIDER_ALLOC( 3 * sizeof(HROW) );
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
2, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
1, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
2, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
3, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
3, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
3, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows2 // optional arg if client wants to control row handle mem
);
COMPARE(VerifyRowPosition(phRows1[0], 1, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows1[1], 2, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows2[0], 3, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows2[1], 4, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows2[2], 5, g_pCTable), TRUE);
m_pIRowset->ReleaseRows(2, phRows1, NULL, NULL, NULL);
m_pIRowset->ReleaseRows(3, phRows2, NULL, NULL, NULL);
CLEANUP:
PROVIDER_FREE(phRows1);
PROVIDER_FREE(phRows2);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Get 1,2 rows. Get 3 row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CanHoldRows::Variation_2()
{
HROW *phRows1, *phRows2;
BOOL fTestPass = TRUE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
phRows1 = (HROW *) PROVIDER_ALLOC( 2 * sizeof(HROW) );
phRows2 = (HROW *) PROVIDER_ALLOC( sizeof(HROW) );
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
2, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
1, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
2, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
1, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
3, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
1, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows2 // optional arg if client wants to control row handle mem
);
COMPARE(VerifyRowPosition(phRows1[0], 1, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows1[1], 2, g_pCTable),TRUE);
COMPARE(VerifyRowPosition(phRows2[0], 3, g_pCTable),TRUE);
m_pIRowset->ReleaseRows(2, phRows1, NULL, NULL, NULL);
m_pIRowset->ReleaseRows(1, phRows2, NULL, NULL, NULL);
CLEANUP:
PROVIDER_FREE(phRows1);
PROVIDER_FREE(phRows2);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Get all rows with GetNextRows. RestartPosition. FindNext with pBookmark=NULL, Offset=1, cRows=1 and match 2nd. Verify S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CanHoldRows::Variation_3()
{
BOOL fTestPass = FALSE;
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained = 0;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, g_lRowLast, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, ULONG(g_lRowLast)))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phrow[0], 1, g_pCTable), TRUE))
goto CLEANUP;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
CLEANUP:
PROVIDER_FREE(phrow);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL CanHoldRows::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Scroll_and_Fetch)
//*-----------------------------------------------------------------------
//| Test Case: Scroll_and_Fetch - Test in context of CANSCROLLBACKWARDS and CANFETCHBACKWARDS
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_and_Fetch::Init()
{
DBPROPID guidPropertySet[2];
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidPropertySet[cPrptSet]=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet[cPrptSet]=DBPROP_CANSCROLLBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS and DBPROP_CANSCROLLBACKWARDS
//are requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET and no hrows.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_1()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
0, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST,cRows=2 Match 3rd row. Verify S_OK and hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_2()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
2, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_LAST,cRows=-2. Match 3rd row. Verify S_OK and 3rd and 2nd hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_3()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-2, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_LAST,cRows=-# rows. Match last row. Verify DB_S_ENDOFROWSET and all rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_4()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-(g_lRowLast+1), // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
g_lRowLast // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST, cRows=-1. Match first row. Verify S_OK and one row handle.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_5()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST,cRows=1. Match last row. FindNext, cRows=1, Offset=1 and match last. then cRows=-3, match 4th
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_6()
{
BOOL fTestPass = TRUE;
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
// next fetch position is still at start of rowset.
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-3, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
3 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_LAST,cRows=1. Match last row. Call FindNext, cRows=-3, pBookmark=NULL. Match 4th row, S_OK.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_7()
{
BOOL fTestPass = TRUE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-3, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
3 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=DBBMK_LAST, Offset=-2, cRows=-3. Verify row starting with N-4 fetched in traversal order
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_8()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
-2, // offset
g_ulColNum, // Which column to match
g_lRowLast-4, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, Offset=-2, cRows=-1. Verify N-2 row is fetched and fetch position is after N-3 row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_9()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
-2, // offset
g_ulColNum, // Which column to match
g_lRowLast-2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, Offset=-4, cRows=2 and match last. Verify DB_S_END. Again cRows=-1 and no match. Again cRows=1 and match 1st.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_10()
{
BOOL fTestPass;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
-4, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
0, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
CLEANUP:
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=3 and match last. DB_S_END. Again with cRows=2, verify DB_S_END.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_and_Fetch::Variation_11()
{
BOOL fTestPass;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
3, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
CLEANUP:
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_and_Fetch::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Boundary)
//*-----------------------------------------------------------------------
//| Test Case: Boundary - Test invalid arguments
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Boundary::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCHAPTER
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_1()
{
return TEST_SKIPPED;
#if 0
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained;
HROW *rghRows = NULL;
HCHAPTER hBadChapter;
memset(&hBadChapter, 0xCA, sizeof(HCHAPTER));
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(hBadChapter, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( !COMPARE(m_hr,DB_E_BADCHAPTER) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
PROVIDER_FREE(rghRows);
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
#endif
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG, cbBookmark != 0, pBookmark = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_2()
{
BOOL fTestPass = TRUE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
MAXDBCOUNTITEM, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
E_INVALIDARG, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG, pcRowsObtained = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_3()
{
BOOL fTestPass = TRUE;
HROW *rghRows = NULL;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
1, NULL, &rghRows);
// Verify HRESULT
if ( !COMPARE(m_hr,E_INVALIDARG) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
PROVIDER_FREE(rghRows);
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG prghRows = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_4()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
1, &cRowsObtained, NULL);
// Verify HRESULT
if ( !COMPARE(m_hr,E_INVALIDARG) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc DB_E_COMPAREOPS, CompareOp = -1 (<min
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_5()
{
BOOL fTestPass = TEST_PASS;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(fTestPass=CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
-1, 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
if (!CHECK(m_hr, DB_E_BADCOMPAREOP))
fTestPass = TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, CompareOp > max
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_6()
{
BOOL fTestPass = TEST_PASS;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(fTestPass==CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NOTCONTAINS+1, 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
if (!CHECK(m_hr, DB_E_BADCOMPAREOP))
fTestPass = TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, unsupported
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_7()
{
BOOL fTestPass=TRUE;
CCol TempCol;
DBORDINAL ulColNum = g_pCTable->CountColumnsOnTable();
DBCOUNTITEM ulRowCount = g_pCTable->GetRowsOnCTable();
DBORDINAL ulColIndex;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
for (ulColIndex = 1; ulColIndex <= ulColNum; ulColIndex++ )
{
g_pCTable->GetColInfo(ulColIndex, TempCol);
for ( DWORD CompareOp = 0; CompareOp <= DBCOMPAREOPS_IGNORE; CompareOp++ )
{
//skip non-updable columns as we ca not call MakeData for them
if (TempCol.GetUpdateable() && !IsColumnMinimumFindable(&TempCol, CompareOp) )
{
fTestPass =
CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
TRUE, // skip current row
ulColIndex, // Which column to match
1, // row to match
DB_E_BADCOMPAREOP, // HRESULT to verify
0, // How many rows to expect.
TRUE, //fReleaseRows
CompareOp // Specifically ask for a compare Op
);
if ( fTestPass == TEST_FAIL )
{
odtLog<<"Error at ColName "<< TempCol.GetColName()<<L", ColIndex "<<ulColIndex<<L"; column type: "<<TempCol.GetProviderType()<<L"; CompareOp: "<<CompareOp<< ENDL;
odtLog<<"-------------------------------------------------------------"<< ENDL;
break;
}
}
}
}
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADBINDINFO, NULL hAccessor
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_8()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW *rghRows = NULL;
HRESULT hr = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
// Lets create the accessor.
if ( FAILED(hr= m_pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 0, NULL, sizeof(DBLENGTH)+sizeof(DBSTATUS),
&m_hRowsetFindAccessor, NULL)) )
{
if(hr==DB_E_NULLACCESSORNOTSUPPORTED)
TESTC_DRIVER(FALSE); //skip if null accessor is not supported
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Check that for DBCOMPAREOPS_IGNORE the accessor and pData are ignored.
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, NULL,
DBCOMPAREOPS_IGNORE, 0, NULL, FALSE,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( !CHECK(m_hr,S_OK) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(cRowsObtained,1))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADBINDINFO, 2 columns bound
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_9()
{
// Not an interesting test.
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADBINDINFO, many columns bound
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_10()
{
BOOL fTestPass = TEST_FAIL;
DBCOUNTITEM cRowsObtained = 0;
HROW *rghRows = NULL;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
// use accessor from GetRowsetAndAccessor
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hAccessor, m_pData,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( !CHECK(m_hr,DB_E_BADBINDINFO) )
goto CLEANUP;
if ( !COMPARE(cRowsObtained, 0) )
goto CLEANUP;
if ( !COMPARE(rghRows, NULL) )
goto CLEANUP;
fTestPass = TEST_PASS;
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc DB_E_CANTSCROLLBACKWARDS. lRowsOffset<0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_11()
{
BOOL fTestPass = TRUE;
if(g_rgDBPrpt[IDX_ScrollBackwards].fSupported && g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
return TEST_SKIPPED;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
-1, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_E_CANTSCROLLBACKWARDS, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc DB_E_CANTSCROLLBACKWARDS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_12()
{
BOOL fTestPass = TRUE;
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
if(g_rgDBPrpt[IDX_ScrollBackwards].fSupported && g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
return TEST_SKIPPED;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_E_CANTSCROLLBACKWARDS, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc DB_E_CANTSCROLLBACKWARDS, pBookmark = DBBMK_FIRST
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_13()
{
BOOL fTestPass = TRUE;
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
if(g_rgDBPrpt[IDX_ScrollBackwards].fSupported && g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
return TEST_SKIPPED;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_E_CANTSCROLLBACKWARDS, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc DB_E_CANTSCROLLBACKWARDS, pBokmark = DBBMK_LAST
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_14()
{
BOOL fTestPass = TRUE;
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
if(g_rgDBPrpt[IDX_ScrollBackwards].fSupported && g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
return TEST_SKIPPED;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_E_CANTSCROLLBACKWARDS, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc DB_E_CANTFETCHBACKWARDS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_15()
{
BOOL fTestPass = TRUE;
if(g_rgDBPrpt[IDX_FetchBackwards].fSupported && g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
return TEST_SKIPPED;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_E_CANTFETCHBACKWARDS, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, IGNORE and CASESENSITIVE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_16()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 1;
CCol TempCol;
g_pCTable->GetColInfo(g_ulColNum, TempCol);
if(!IsColumnMinimumFindable(&TempCol, DBCOMPAREOPS_IGNORE | DBCOMPAREOPS_CASESENSITIVE))
return TEST_SKIPPED;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_IGNORE | DBCOMPAREOPS_CASESENSITIVE, 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
// should be treated as an DBCOMPAREOPS_IGNORE
if (!CHECK(m_hr, S_OK))
fTestPass = TEST_FAIL;
// Verify cRowsObtained
if ( !COMPARE(cRowsObtained,1) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(rghRows[0],1,g_pCTable),TRUE))
fTestPass=TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, just CASESENSITIVE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_17()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_CASESENSITIVE | (DBCOMPAREOPS_NOTCONTAINS+1), 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
if (!CHECK(m_hr, DB_E_BADCOMPAREOP))
fTestPass = TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, just caseinsensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_18()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_CASEINSENSITIVE | -1 , 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
if (!CHECK(m_hr, DB_E_BADCOMPAREOP))
fTestPass = TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOMPAREOP, both case sensitive and insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_19()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ | DBCOMPAREOPS_CASESENSITIVE | DBCOMPAREOPS_CASEINSENSITIVE,
0, NULL, FALSE, lRowsToFetch, &cRowsObtained, &rghRows);
if (!CHECK(m_hr, DB_E_BADCOMPAREOP))
fTestPass = TEST_FAIL;
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ENDOFROWSET, search for null on non-nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Boundary::Variation_20()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained;
HROW* rghRows = NULL;
DBORDINAL ulColToFind = 0;
DBTYPE wColType;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
if (!GetNonNullableCol(&ulColToFind, DBCOMPAREOPS_EQ, FALSE, &wColType))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, ulColToFind, wColType, SUBOP_EMPTY));
// Overwrite the status to search for NULL
ASSERT(DBSTATUS_S_OK == *(DBSTATUS *)(m_pFindValue+offsetof(DATA,sStatus)));
*(DBSTATUS *)(m_pFindValue+offsetof(DATA,sStatus)) = DBSTATUS_S_ISNULL;
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
1, &cRowsObtained, &rghRows);
// reset status so that ReleaseFindValueAccessor
// can clean any embedded pointers
*(DBSTATUS *)(m_pFindValue+offsetof(DATA,sStatus)) = DBSTATUS_S_OK;
TESTC_(m_hr,DB_S_ENDOFROWSET);
TESTC(cRowsObtained==0);
TESTC(rghRows==NULL);
CLEANUP:
PROVIDER_FREE(rghRows);
ReleaseFindValueAccessor(wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Boundary::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(OutputRowHandleAllocation)
//*-----------------------------------------------------------------------
//| Test Case: OutputRowHandleAllocation - Test cRows, prghRows, pcRowsObtained parameters
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL OutputRowHandleAllocation::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc cRows==0, *prghRows != NULL, Verify *prghRows != NULL on output
//
// @rdesc TEST_PASS or TEST_FAIL
//
int OutputRowHandleAllocation::Variation_1()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( !COMPARE(m_hr,S_OK) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Verify rghRows
if ( !COMPARE(rghRows,NULL) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Verify cRowsObtained
if ( !COMPARE(cRowsObtained,0) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc *pcRowsObtained = 0, *prghRows = NULL. Verify *prghRows = NULL on output
//
// @rdesc TEST_PASS or TEST_FAIL
//
int OutputRowHandleAllocation::Variation_2()
{
BOOL fTestPass = TRUE;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBROWCOUNT lRowsToFetch = 1;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
//setup - make sure no match occurs by matching to row #0
TESTC(fTestPass=CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 0, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, FALSE,
lRowsToFetch, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( !COMPARE(m_hr,DB_S_ENDOFROWSET) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Verify rghRows
if ( !COMPARE(rghRows,NULL) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
// Verify cRowsObtained
if ( !COMPARE(cRowsObtained,0) )
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
CLEANUP:
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=0, Match last. Verify S_OK. Set fSkip=1, cRows = 1, pBookmark = NULL, match last. DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int OutputRowHandleAllocation::Variation_3()
{
// TO DO: Add your own code here
return TEST_SKIPPED;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=LONG_MAX. fSkip=0. Match first row. Verify DB_S_ENDOFROWSET and all rows in rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int OutputRowHandleAllocation::Variation_4()
{
BOOL fTestPass = TEST_FAIL;
HROW * rghRows = NULL;
DBCOUNTITEM cRowsObtained = 0;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
//setup
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, g_ulColNum, g_wColType, SUBOP_EMPTY));
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, 0,
MAXDBROWCOUNT, &cRowsObtained, &rghRows);
if (m_hr == E_OUTOFMEMORY)
{
if (!COMPARE(cRowsObtained, 0))
goto CLEANUP;
if (!COMPARE(rghRows, NULL))
goto CLEANUP;
}
else if (m_hr == DB_S_ENDOFROWSET)
{
if (!COMPARE(cRowsObtained, ULONG(g_lRowLast)))
goto CLEANUP;
if(!COMPARE(VerifyRowPosition(rghRows[0],1,g_pCTable),TRUE))
goto CLEANUP;
}
else
{
CHECK(m_hr, DB_S_ENDOFROWSET); // generate a error
goto CLEANUP; // always a test failure at this point
}
fTestPass = TEST_PASS;
CLEANUP:
PROVIDER_FREE(rghRows);
ReleaseFindValueAccessor(g_wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL OutputRowHandleAllocation::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(CompareOp)
//*-----------------------------------------------------------------------
//| Test Case: CompareOp - Test the various compare operations
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL CompareOp::Init()
{
BOOL fTestPass = TEST_PASS;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0, NULL));
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_EQ
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_1()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_EQ, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_LT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_2()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LT, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_LE, Use Equal case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_3()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE, SUBOP_ALWAYS_EQ);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_LE, Use Less Than case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_4()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_GT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_5()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GT, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_GE, Use Equal case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_6()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GE, SUBOP_ALWAYS_EQ);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_GE, Use Greater than case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_7()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_BEGINSWITH
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_8()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_BEGINSWITH, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_CONTAINS, match start of string
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_9()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_BEGIN);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_CONTAINS, match middle of string
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_10()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_MIDDLE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_CONTAINS, match end of string
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_11()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_END);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_NE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_12()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_IGNORE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_13()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_IGNORE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_NOTBEGINSWITH
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_14()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NOTBEGINSWITH, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_NOTCONTAINS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_15()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NOTCONTAINS, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_CONTAINS, use Equal case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_16()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_ALWAYS_EQ);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc COMPAREOPS_BEGINSWITH, Use Equal case
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CompareOp::Variation_17()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_BEGINSWITH, SUBOP_ALWAYS_EQ);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL CompareOp::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(fSkipCurrent)
//*-----------------------------------------------------------------------
//| Test Case: fSkipCurrent - Test for correct behavior with fSkipCurrent flag
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL fSkipCurrent::Init()
{
BOOL fTestPass = FALSE;
DBPROPID guidPropertySet;
ULONG cPrptSet=0;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet=DBPROP_CANSCROLLBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidPropertySet));
CLEANUP:
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc fSkip=0, cRows=1. Match 1st. Verify S_OK and one row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int fSkipCurrent::Variation_1()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
1, // offset
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Match 1st row. pBookMark=NULL, fSkip=TRUE. Match 1st row. DB_S_ENDOFROWSET and no row handles.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int fSkipCurrent::Variation_2()
{
BOOL fTestPass = FALSE;
DBBOOKMARK dbBookmark = DBBMK_FIRST;
BYTE *pBookmark = (BYTE *)&dbBookmark;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
1, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
-1, // offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Match 5th row. pBookMark=NULL, fSkip=FALSE. Match 5th row. S_OK and no row handles.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int fSkipCurrent::Variation_3()
{
BOOL fTestPass = FALSE;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
5, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
1, // offset
g_ulColNum, // Which column to match
5, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL fSkipCurrent::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(pFindValue)
//*-----------------------------------------------------------------------
//| Test Case: pFindValue - Test the various coercions possible
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL pFindValue::Init()
{
DBPROPID guidPropertySet;
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidPropertySet));
CLEANUP:
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc IStorage compares, DBCOMPAREOPS_EQ
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_1()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_EQ, SUBOP_EMPTY, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_BEGINSWITH
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_2()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_BEGINSWITH, SUBOP_EMPTY, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_GT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_3()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GT, SUBOP_EMPTY, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_GE (EQUAL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_4()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_EQ, SUBOP_ALWAYS_EQ, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_GE (Greater
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_5()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GE, SUBOP_EMPTY, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_LT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_6()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LT, SUBOP_EMPTY, TRUE) ;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_LE (EQUAL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_7()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE, SUBOP_ALWAYS_EQ, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_LE (Less
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_8()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE, SUBOP_EMPTY, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_CONTAINS, beginning
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_9()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_BEGIN, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_CONTAINS, middle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_10()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_MIDDLE, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc IStorage, DBCOMPAREOPS_CONTAINS, end
//
// @rdesc TEST_PASS or TEST_FAIL
//
int pFindValue::Variation_11()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS, SUBOP_CONTAINS_END, TRUE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL pFindValue::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(SingleRowRowset)
//*-----------------------------------------------------------------------
//| Test Case: SingleRowRowset - Test on a one row rowset
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL SingleRowRowset::Init()
{
if (!g_p1RowTable)
return TEST_SKIPPED;
if(!TCIRowsetFind::Init())
return FALSE;
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkip=TRUE. DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SingleRowRowset::Variation_1()
{
BOOL fTestPass;
DBPROPID guidProperty[1];
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
guidProperty[0]=DBPROP_CANSCROLLBACKWARDS;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_p1RowTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_PASS; // OK to pass if properties aren't supported
goto CLEANUP;
}
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
1, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Match 1st. pBookMark = DBBMK_FIRST, cRows=1, fSkipCurrent = FALSE. S_OK and one row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SingleRowRowset::Variation_2()
{
BOOL fTestPass;
DBPROPID guidProperty[1];
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
guidProperty[0]=DBPROP_CANSCROLLBACKWARDS;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_p1RowTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_PASS; // OK to pass if properties aren't supported
goto CLEANUP;
}
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Match First. pBookmark = DBBMK_LAST. cRows=-1, fSkip=TRUE. DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SingleRowRowset::Variation_3()
{
BOOL fTestPass;
DBPROPID guidProperty[2];
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
guidProperty[0]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[1]=DBPROP_CANFETCHBACKWARDS;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_p1RowTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_PASS; // OK to pass if properties aren't supported
goto CLEANUP;
}
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
1, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Match first. pBookMark=DBBMK_LAST. cRows=-1. fSkip=-1. fSkip=FALSE. S_OK and 1 hrow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int SingleRowRowset::Variation_4()
{
BOOL fTestPass;
DBPROPID guidProperty[2];
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
guidProperty[0]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[1]=DBPROP_CANFETCHBACKWARDS;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_p1RowTable, SELECT_ALLFROMTBL, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_PASS; // OK to pass if properties aren't supported
goto CLEANUP;
}
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_p1RowTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
0, // lOffset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL SingleRowRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Related_RestartPosition)
//*-----------------------------------------------------------------------
//| Test Case: Related_RestartPosition - Test in conjunction with RestartPosition
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Related_RestartPosition::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Match 5th. Restart. Call Find, cRows=1, fSkip=TRUE, match 5th. Verify DB_S_ENDOFROWSET (because of restart
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_RestartPosition::Variation_1()
{
return TRUE;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Match 5th. Restart. Call Find, cRows=1, fSkip=FALSE, match 4th. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_RestartPosition::Variation_2()
{
return TRUE;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Match Last. Restart. Call Find, cRows=1, fSkip=TRUE. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_RestartPosition::Variation_3()
{
return TRUE;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Related_RestartPosition::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Related_GetNextRows)
//*-----------------------------------------------------------------------
//| Test Case: Related_GetNextRows - Test in conjunction with GetNextRows
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Related_GetNextRows::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_FIRST, Verify GetNextRows pos not changed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_1()
{
BOOL fTestPass = FALSE;
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE * pBookmark=(BYTE *)&DBBookmark;
DBCOUNTITEM cRowsObtained = 0;
HROW * phrow = NULL;
DBPROPID guidPropertySet[1];
ULONG cPrptSet=0;
TESTC_DRIVER(g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet[cPrptSet++]=DBPROP_CANSCROLLBACKWARDS;
}
//create a rowset and an accessor.
//DBPROP_CANSCROLLBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
// using pBookmark = DBBMK_LAST should not affect GetNextRows position
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],1,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Use pBookmark=middle bmk. Verify GetNextRows pos not changed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_2()
{
BOOL fTestPass = FALSE;
BYTE * pBookmark=NULL;
DBCOUNTITEM cRowsObtained = 0;
ULONG_PTR cbBookmark = 0;
HROW * phrow = NULL;
IRowsetLocate * pIRowsetLocate = NULL;
DBPROPID guidProperty[1];
guidProperty[0]=DBPROP_IRowsetLocate;
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty), guidProperty));
if ( !VerifyInterface(m_pIRowset, IID_IRowsetLocate, ROWSET_INTERFACE, (IUnknown **)&pIRowsetLocate))
goto CLEANUP;
GetBookmark(g_lRowLast/2, &cbBookmark, &pBookmark);
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast-2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
// using pBookmark = g_lRowLast/2 should not affect GetNextRows position
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],1,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(pBookmark);
PROVIDER_FREE(phrow);
SAFE_RELEASE(pIRowsetLocate);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Use pBookMark = DBBMK_LAST, Verify GetNextRows pos not changed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_3()
{
BOOL fTestPass = FALSE;
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE * pBookmark=(BYTE *)&DBBookmark;
DBCOUNTITEM cRowsObtained = 0;
HROW * phrow = NULL;
DBPROPID guidPropertySet[1];
ULONG cPrptSet=0;
TESTC_DRIVER(g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet[cPrptSet++]=DBPROP_CANSCROLLBACKWARDS;
}
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
// using pBookmark = DBBMK_LAST should not affect GetNextRows position
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],1,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc use pBookmark=NULL, match 1st row. Verify GetNextRows pos is after 1st row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_4()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
// using pBookmark = NULL should affect GetNextRows position
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],2,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Use pBookmark=NULL, match last row. Verify GetNextRows with cRows=1 returns DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_5()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
// using pBookmark = NULL should affect GetNextRows position
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), DB_S_ENDOFROWSET) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 0))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(phrow,NULL))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Use pBookmark=NULL, match middle row. Use pBookmark=2nd bmk and match 2nd. Verify GetNextRows is still after middle row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_6()
{
BOOL fTestPass = FALSE;
BYTE *pBookmark=NULL;
DBCOUNTITEM cRowsObtained = 0;
ULONG_PTR cbBookmark = 0;
HROW *phrow = NULL;
IRowsetLocate *pIRowsetLocate = NULL;
DBPROPID PropID = DBPROP_IRowsetFind;
ULONG cPrptSet=1;
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetLocate,
cPrptSet,&PropID));
if ( !VerifyInterface(m_pIRowset, IID_IRowsetLocate, ROWSET_INTERFACE, (IUnknown **)&pIRowsetLocate))
goto CLEANUP;
GetBookmark(2, &cbBookmark, &pBookmark);
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast/2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],(g_lRowLast/2)+1,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
PROVIDER_FREE(pBookmark);
SAFE_RELEASE(pIRowsetLocate);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Call GetNextRows with last row fetched = 3. Call FindNextRows, pBookmark=NULL,cRows=-1 to match 4th. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_7()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
DBPROPID guidProperty;
ULONG cPrptSet = 0;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidProperty=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 3, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
4, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc GetNextRows, cRows=1, Offset=0. Verify S_OK. FindNext with pBookmark=NULL, cRows=1 and match 1st. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_8()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
DBPROPID guidProperty;
ULONG cPrptSet = 0;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidProperty=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc FindNext with pBookmark=NULL, cRows=2 and match 4th. GetNextRows with cRows=-3. Verify 5,4,3 row handles.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_9()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
DBPROPID guidProperty;
ULONG cPrptSet = 0;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidProperty=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
if ( !COMPARE(fTestPass,TRUE) )
goto CLEANUP;
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, -3, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],5,g_pCTable),TRUE))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[1],4,g_pCTable),TRUE))
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[2],3,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc FindNext, pBookmark=NULL, match last. FindNext, pBmk=NULL, cRows=-1, match last. GetNext. cRows=-1 and verify next to last
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Related_GetNextRows::Variation_10()
{
BOOL fTestPass = FALSE;
DBCOUNTITEM cRowsObtained = 0;
HROW *phrow = NULL;
DBPROPID guidProperty;
ULONG cPrptSet = 0;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidProperty=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS is requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidProperty));
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass,TRUE) )
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass,TRUE) )
goto CLEANUP;
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, -1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
//call VerifyRowPosition
if(!COMPARE(VerifyRowPosition(phrow[0],g_lRowLast-1,g_pCTable),TRUE))
goto CLEANUP;
if (!CHECK(m_pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Related_GetNextRows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Scroll_BookMark)
//*-----------------------------------------------------------------------
//| Test Case: Scroll_BookMark - CanScrollBackwards with bookmarks
//| Created: 06/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_BookMark::Init()
{
BOOL fTestPass = FALSE;
DBPROPID guidPropertySet[2];
ULONG cPrptSet=0;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_OrderedBookmarks].fSupported &&
g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
if(!g_rgDBPrpt[IDX_IRowsetLocate].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_IRowsetLocate;
if(!g_rgDBPrpt[IDX_OrderedBookmarks].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_ORDEREDBOOKMARKS;
//DBPROP_ORDEREDBOOKMARKS and DBPROP_IRowsetLocate
//are requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST, cRows=1. Match first row. Verify S_OK and one row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_1()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_LAST,cRows=1. Match last row. Verify S_OK and last row
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_2()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_INVALID. Verify DB_E_BADBOOKMARK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_3()
{
DBBOOKMARK DBBookmark=DBBMK_INVALID;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_E_BADBOOKMARK, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=one bookmark for each row, cRows=1. Always match current row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_4()
{
BOOL fTestPass;
ULONG_PTR cbBookmark;
BYTE *pBookmark;
for ( LONG i = 1; i <= g_lRowLast; i++ )
{
GetBookmark(i, &cbBookmark, &pBookmark);
fTestPass = CallFindNextRows(
g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
i, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( fTestPass == TEST_FAIL ) break;
PROVIDER_FREE(pBookmark);
}
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=random value. Verify DB_E_BADBOOKMARK (warning-could get a provider specific error
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_5()
{
BYTE pBookmark[4];
memset(pBookmark, 0xCA, 4);
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
4, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_E_BADBOOKMARK, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=2nd row and offset=-1, cRows=1. Verify first row matched.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_6()
{
BOOL fTestPass = FALSE;
ULONG_PTR cbBookmark;
BYTE *pBookmark;
GetBookmark(2, &cbBookmark, &pBookmark);
fTestPass= CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
-1, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=4th row, Offset=2, cRows=1 and match 5th row. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_7()
{
BOOL fTestPass = FALSE;
ULONG_PTR cbBookmark;
BYTE *pBookmark;
GetBookmark(4, &cbBookmark, &pBookmark);
fTestPass= CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
2, // Offset
g_ulColNum, // Which column to match
5, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=5th row. Offset=0, cRows=1 and match 5th. Again with pBookmark=NULL, Offset=0, cRows=1 and match 2nd. Verify S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_8()
{
BOOL fTestPass = FALSE;
ULONG_PTR cbBookmark;
BYTE *pBookmark;
GetBookmark(5, &cbBookmark, &pBookmark);
fTestPass= CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
5, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if ( !COMPARE(fTestPass, TRUE) )
goto CLEANUP;
fTestPass= CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
CLEANUP:
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc *pBookmark=2nd row and offset = -2, cRows=1, Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_9()
{
BOOL fTestPass = FALSE;
ULONG_PTR cbBookmark;
BYTE *pBookmark;
GetBookmark(2, &cbBookmark, &pBookmark);
fTestPass= CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
-2, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_FIRST, cRows=0 Should be no-op
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_BookMark::Variation_10()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
0, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast+1, // row to match
S_OK, // HRESULT to verify
0 // How many rows to expect.
);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_BookMark::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Scroll_Fetch_Bookmarks)
//*-----------------------------------------------------------------------
//| Test Case: Scroll_Fetch_Bookmarks - CanScrollBackwards and CanFetchBackwards with Bookmarks
//| Created: 06/24/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_Fetch_Bookmarks::Init()
{
BOOL fTestPass = FALSE;
DBPROPID guidPropertySet[4];
ULONG cPrptSet=0;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_OrderedBookmarks].fSupported &&
g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANFETCHBACKWARDS;
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANSCROLLBACKWARDS;
if(!g_rgDBPrpt[IDX_OrderedBookmarks].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_ORDEREDBOOKMARKS;
if(!g_rgDBPrpt[IDX_IRowsetLocate].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_IRowsetLocate;
//DBPROP_ORDEREDBOOKMARKS,DBPROP_CANFETCHBACKWARDS and DBPROP_CANSCROLLBACKWARDS
//are requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST, cRows=5 and match 1st row. Verify S_OK and 5 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Bookmarks::Variation_1()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
5, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
5 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookMarks=DBBMK_LAST,cRows=-5 match last row. Verify S_OK and 5 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Bookmarks::Variation_2()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
return CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-5, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
S_OK, // HRESULT to verify
5 // How many rows to expect.
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=2nd row, cRows=2, Offset=1. Match 4th row. Verify S_OK and 2 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Bookmarks::Variation_3()
{
BOOL fTestPass;
ULONG_PTR cbBookmark;
BYTE *pBookmark=NULL;
//get the bookmark for the 2th ro
if(!GetBookmark(2,&cbBookmark, &pBookmark))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
2, // # rows to fetch
1, // Offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=5th row, cRows=-2. Match3rd row. Verify S_OK and 2 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Bookmarks::Variation_4()
{
BOOL fTestPass;
ULONG_PTR cbBookmark;
BYTE *pBookmark=NULL;
//get the bookmark for the 2th row
if(!GetBookmark(5,&cbBookmark, &pBookmark))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
-2, // # rows to fetch
2, // Offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=Last row, cRows=1, Offset=1. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Bookmarks::Variation_5()
{
BOOL fTestPass;
ULONG_PTR cbBookmark;
BYTE * pBookmark=NULL;
//get the bookmark for the last
if(!GetBookmark(g_lRowLast,&cbBookmark, &pBookmark))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
-1, // # rows to fetch
1, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_Fetch_Bookmarks::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(CaseSensitive_Compares)
//*-----------------------------------------------------------------------
//| Test Case: CaseSensitive_Compares - Test the case sensitive property
//| Created: 06/26/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL CaseSensitive_Compares::Init()
{
DBPROPID guidPropertySet;
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidPropertySet));
CLEANUP:
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc EQ, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_1()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_EQ | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc EQ, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_2()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_EQ | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc LT, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_3()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LT | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc LT, insensitve
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_4()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LT | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc LE, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_5()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc LE, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_6()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_LE | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc GT, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_7()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GT | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc GT, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_8()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GT | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc GE, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_9()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GE | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc GE, insensitve
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_10()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_GE | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc NE, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_11()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NE | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc NE, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_12()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NE | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc BEGINSWITH, sensitve
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_13()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASESENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc BEGINSWITH, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_14()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc BEGINSWITH, sensitive negative match
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_15()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
CCol TempCol;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_BEGINSWITH, FALSE, &wColType))
goto CLEANUP;
g_pCTable->GetColInfo(ulColToFind, TempCol);
if(!ValidateCompareOp(TC_FindCompareOps(TempCol.GetColID()), DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASESENSITIVE))
return TEST_SKIPPED;
//setup
//set up a INSENSITIVE match binding
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_EMPTY));
// But actually use a CASESENSITIVE operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASESENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (!CHECK(m_hr, DB_S_ENDOFROWSET))
{
odtLog << "Found a match, when the match should have failed." << ENDL;
fTestPass = TEST_FAIL;
goto CLEANUP;
}
fTestPass = TEST_PASS;
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc CONTAINS, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_16()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASESENSITIVE, SUBOP_CONTAINS_BEGIN);
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc CONTAINS, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_17()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_CONTAINS_BEGIN);
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc CONTAINS, sensitive negative match
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_18()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
CCol TempCol;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_CONTAINS, FALSE, &wColType))
goto CLEANUP;
g_pCTable->GetColInfo(ulColToFind, TempCol);
if(!ValidateCompareOp(TC_FindCompareOps(TempCol.GetColID()), DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASESENSITIVE))
return TEST_SKIPPED;
//setup
//set up a INSENSITIVE match binding
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_CONTAINS_BEGIN));
// But actually use a CASESENSITIVE operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASESENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (!CHECK(m_hr, DB_S_ENDOFROWSET))
{
odtLog << "Found a match, when the match should have failed." << ENDL;
fTestPass = TEST_FAIL;
}
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc NOTBEGINSWITH, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_19()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_NOTBEGINSWITH, FALSE, &wColType))
goto CLEANUP;
//setup
//set up a INSENSITIVE BEGINSWITH match binding to create lower case version of the data
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_EMPTY));
// But actually use a CASESENSITIVE with NOTBEGINSWITH operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NOTBEGINSWITH | DBCOMPAREOPS_CASESENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (!CHECK(m_hr, S_OK))
{
odtLog << "Didn't find a match." << ENDL;
fTestPass = TEST_FAIL;
}
if(!COMPARE(cRowsObtained,1) || !COMPARE(VerifyRowPosition(rghRows[0], 1, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
else
fTestPass = TEST_PASS;
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc NOTBEGINSWITH, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_20()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NOTBEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_EMPTY);
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc NOTBEGINSWITH, sensitive negative match
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_21()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
CCol TempCol;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_NOTBEGINSWITH, FALSE, &wColType))
goto CLEANUP;
g_pCTable->GetColInfo(ulColToFind, TempCol);
if(!ValidateCompareOp(TC_FindCompareOps(TempCol.GetColID()), DBCOMPAREOPS_NOTBEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE))
return TEST_SKIPPED;
//setup
//set up a BEGINSWITH INSENSITIVE match binding
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_BEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_EMPTY));
// Use a CASEINSENSITIVE operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NOTBEGINSWITH | DBCOMPAREOPS_CASEINSENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (cRowsObtained != 0 && VerifyRowPosition(rghRows[0], 1, g_pCTable))
{
odtLog << "Found a match on first row, when the match should have failed." << ENDL;
fTestPass = TEST_FAIL;
goto CLEANUP;
}
fTestPass = TEST_PASS;
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc NOTCONTAINS, sensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_22()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
CCol TempCol;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_NOTCONTAINS, FALSE, &wColType))
goto CLEANUP;
g_pCTable->GetColInfo(ulColToFind, TempCol);
if(!ValidateCompareOp(TC_FindCompareOps(TempCol.GetColID()), DBCOMPAREOPS_NOTCONTAINS | DBCOMPAREOPS_CASESENSITIVE))
return TEST_SKIPPED;
//setup
//set up a INSENSITIVE CONTAINS match binding to create lower case version of the data
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_CONTAINS_BEGIN));
// But actually use a CASESENSITIVE with NOTBEGINSWITH operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NOTCONTAINS | DBCOMPAREOPS_CASESENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (!CHECK(m_hr, S_OK))
{
odtLog << "Didn't find a match, but should have" << ENDL;
fTestPass = TEST_FAIL;
}
if(!COMPARE(cRowsObtained,1) || !COMPARE(VerifyRowPosition(rghRows[0], 1, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
else
fTestPass = TEST_PASS;
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc NOCONTAINS, insensitive
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_23()
{
return CompareOpTest(g_pCTable, DBCOMPAREOPS_NOTCONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, SUBOP_CONTAINS_BEGIN);
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc NOCONTAINS, sensitive negative match
//
// @rdesc TEST_PASS or TEST_FAIL
//
int CaseSensitive_Compares::Variation_24()
{
BOOL fTestPass = TEST_SKIPPED;
DBCOUNTITEM cRowsObtained = 0;
DBORDINAL ulColToFind;
DBTYPE wColType;
HROW * rghRows = NULL;
CCol TempCol;
m_pIRowset->RestartPosition(DB_NULL_HCHAPTER);
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_NOTCONTAINS, FALSE, &wColType))
goto CLEANUP;
g_pCTable->GetColInfo(ulColToFind, TempCol);
if(!ValidateCompareOp(TC_FindCompareOps(TempCol.GetColID()), DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASESENSITIVE))
return TEST_SKIPPED;
//setup
//set up a CONTAINS INSENSITIVE match binding to generate lower case data
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, g_pCTable, 1, ulColToFind, wColType, SUBOP_CONTAINS_BEGIN));
// Use a CASEINSENSITIVE operator
m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NOTCONTAINS | DBCOMPAREOPS_CASEINSENSITIVE, 0, NULL, 0,
1, &cRowsObtained, &rghRows);
// Verify HRESULT
if ( m_hr == DB_E_BADCOMPAREOP )
{
// The provider only supported case insensitive compares
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
else if (cRowsObtained != 0 && VerifyRowPosition(rghRows[0], 1, g_pCTable))
{
odtLog << "Found a match on first row, when the match should have failed." << ENDL;
fTestPass = TEST_FAIL;
goto CLEANUP;
}
fTestPass = TEST_PASS;
CLEANUP:
if (cRowsObtained>0)
{
m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL);
PROVIDER_FREE(rghRows);
}
ReleaseFindValueAccessor(wColType);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL CaseSensitive_Compares::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Scroll_Fetch_Hold)
//*-----------------------------------------------------------------------
//| Test Case: Scroll_Fetch_Hold - Test with CanScrollBack, CanFetchBack, and CanHoldRows
//| Created: 06/26/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_Fetch_Hold::Init()
{
DBPROPID guidPropertySet[3];
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_IRowsetLocate].fSupported &&
g_rgDBPrpt[IDX_CanHoldRows].fSupported);
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANFETCHBACKWARDS;
if(!g_rgDBPrpt[IDX_CanHoldRows].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANHOLDROWS;
if(!g_rgDBPrpt[IDX_IRowsetLocate].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_IRowsetLocate;
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS and DBPROP_CANSCROLLBACKWARDS and DBPROP_CANHOLDROWS
//are requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=2nd row, cRows=-1. Verify S_OK and one row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Hold::Variation_1()
{
BOOL fTestPass;
ULONG_PTR cbBookmark;
BYTE *pBookmark=NULL;
//get the bookmark for the 2th row
if(!GetBookmark(2,&cbBookmark, &pBookmark))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
-1, // # rows to fetch
-1, // Offset
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
PROVIDER_FREE(pBookmark);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=3rd row. cRows=3. Match 3rd row. Do not release. pBookmark=4th row, cRows=2, match 4th. Release 1st 3, ver last 2
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Hold::Variation_2()
{
BOOL fTestPass = TEST_PASS;
ULONG_PTR rgcbBookmarks[2];
BYTE *rgpBookmarks[2]={NULL, NULL};
HROW *phRows1, *phRows2;
phRows1 = (HROW *) PROVIDER_ALLOC( 3 * sizeof(HROW) );
phRows2 = (HROW *) PROVIDER_ALLOC( 2 * sizeof(HROW) );
//get the bookmark for the 3rd row
if(!GetBookmark(3,&rgcbBookmarks[0],&rgpBookmarks[0]))
return TEST_FAIL;
//get the bookmark for the 4th row
if(!GetBookmark(4,&rgcbBookmarks[1],&rgpBookmarks[1]))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
rgpBookmarks[0], // bookmark;
rgcbBookmarks[0], // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
3, // How many rows to expect.
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
rgpBookmarks[1], // bookmark;
rgcbBookmarks[1], // Length of bookmark
2, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
2, // How many rows to expect.
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows2 // optional arg if client wants to control row handle mem
);
m_pIRowset->ReleaseRows(3, phRows1, NULL, NULL, NULL);
COMPARE(VerifyRowPosition(phRows2[0], 4, g_pCTable), TRUE);
COMPARE(VerifyRowPosition(phRows2[1], 5, g_pCTable), TRUE);
m_pIRowset->ReleaseRows(2, phRows2, NULL, NULL, NULL);
CLEANUP:
PROVIDER_FREE(phRows1);
PROVIDER_FREE(phRows2);
//free memory pointed by the bookmarks
if(rgpBookmarks[0])
PROVIDER_FREE(rgpBookmarks[0]);
if(rgpBookmarks[1])
PROVIDER_FREE(rgpBookmarks[1]);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=5th,cRows=-5, match 5th. S_OK,5 hrows. pBookmark=4th,cRows=-5. DB_S_ENDOFROWSET and 4 hrows. Release last 4, check 5
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Scroll_Fetch_Hold::Variation_3()
{
BOOL fTestPass = TEST_PASS;
ULONG_PTR rgcbBookmarks[2];
BYTE *rgpBookmarks[2]={NULL, NULL};
HROW *phRows1, *phRows2;
phRows1 = (HROW *) PROVIDER_ALLOC( 5 * sizeof(HROW) );
phRows2 = (HROW *) PROVIDER_ALLOC( 4 * sizeof(HROW) );
//get the bookmark for the 5th row
if(!GetBookmark(5,&rgcbBookmarks[0],&rgpBookmarks[0]))
return TEST_FAIL;
//get the bookmark for the 4th row
if(!GetBookmark(4,&rgcbBookmarks[1],&rgpBookmarks[1]))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
rgpBookmarks[0], // bookmark;
rgcbBookmarks[0], // Length of bookmark
-5, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
5, // row to match
S_OK, // HRESULT to verify
5, // How many rows to expect.
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if ( fTestPass == TEST_FAIL ) goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
rgpBookmarks[1], // bookmark;
rgcbBookmarks[1], // Length of bookmark
-5, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
4, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
4, // How many rows to expect.
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows2 // optional arg if client wants to control row handle mem
);
m_pIRowset->ReleaseRows(4, phRows2, NULL, NULL, NULL);
VerifyRowPosition(phRows1[0], 5, g_pCTable);
VerifyRowPosition(phRows1[1], 4, g_pCTable);
VerifyRowPosition(phRows1[1], 3, g_pCTable);
VerifyRowPosition(phRows1[1], 2, g_pCTable);
VerifyRowPosition(phRows1[1], 1, g_pCTable);
m_pIRowset->ReleaseRows(5, phRows1, NULL, NULL, NULL);
CLEANUP:
PROVIDER_FREE(phRows1);
PROVIDER_FREE(phRows2);
//free memory pointed by the bookmarks
if(rgpBookmarks[0])
PROVIDER_FREE(rgpBookmarks[0]);
if(rgpBookmarks[1])
PROVIDER_FREE(rgpBookmarks[1]);
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Scroll_Fetch_Hold::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Dynamic)
//*-----------------------------------------------------------------------
//| Test Case: Dynamic - Test with OTHERINSERT and OTHERUPDATE properties
//| Created: 06/27/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Dynamic::Init()
{
DBPROPID guidPropertySet[6];
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
if ( !AlteringRowsIsOK() )
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported &&
g_rgDBPrpt[IDX_CanHoldRows].fSupported);
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANFETCHBACKWARDS;
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANSCROLLBACKWARDS;
if(!g_rgDBPrpt[IDX_CanHoldRows].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_CANHOLDROWS;
if(!g_rgDBPrpt[IDX_OtherInsert].fDefault)
guidPropertySet[cPrptSet++]=DBPROP_OTHERINSERT;
if(!g_rgDBPrpt[IDX_IRowsetChange].fDefault)
{
guidPropertySet[cPrptSet++]=DBPROP_IRowsetChange;
guidPropertySet[cPrptSet++]=DBPROP_UPDATABILITY;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS and DBPROP_CANSCROLLBACKWARDS and DBPROP_CANHOLDROWS and DBPROP_OTHERINSERT
//are requested
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet))
return TEST_SKIPPED;
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Insert a new row at end. pBookmark=NULL,cRows=1. Match new row. Verify S_OK and one row handle
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Dynamic::Variation_1()
{
BOOL fTestPass;
// Insert a new row.
if (FAILED(g_pCTable->Insert()))
return TEST_FAIL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast+1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Insert a new row at the end. pBookmark=DBBMK_LAST,cRows=1. DBCOMPAREOPS_IGNORE. Verify S_OK and new row matched.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Dynamic::Variation_2()
{
BOOL fTestPass;
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
// Insert a new row.
if (FAILED(g_pCTable->Insert()))
return TEST_FAIL;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast+1, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Dynamic::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(MaxRows)
//*-----------------------------------------------------------------------
//| Test Case: MaxRows - Test MaxRows property
//| Created: 06/27/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL MaxRows::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Set MAXROWS=3. pBookmark=2nd row. cRows=4. Match 3rd row. DB_S_ENDOFROWSET and 3 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MaxRows::Variation_1()
{
// TO DO: Add your own code here
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Set MAXROWS=2. pBookmark=3rd row,cRows=3. Match 3rd row. DB_S_ROWLIMITEXECEEDED and 2 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MaxRows::Variation_2()
{
// TO DO: Add your own code here
return TEST_PASS;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL MaxRows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(EmptyRowset)
//*-----------------------------------------------------------------------
//| Test Case: EmptyRowset - EmptyRowset
//| Created: 06/27/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL EmptyRowset::Init()
{
DBPROPID guidPropertySet[2];
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if (!g_pEmptyTable)
return TEST_SKIPPED;
if(!TCIRowsetFind::Init())
return FALSE;
TESTC_DRIVER(g_rgDBPrpt[IDX_FetchBackwards].fSupported &&
g_rgDBPrpt[IDX_ScrollBackwards].fSupported );
if(!g_rgDBPrpt[IDX_FetchBackwards].fDefault)
{
guidPropertySet[cPrptSet]=DBPROP_CANFETCHBACKWARDS;
cPrptSet++;
}
if(!g_rgDBPrpt[IDX_ScrollBackwards].fDefault)
{
guidPropertySet[cPrptSet]=DBPROP_CANSCROLLBACKWARDS;
cPrptSet++;
}
//create a rowset and an accessor.
//DBPROP_CANFETCHBACKWARDS and DBPROP_CANSCROLLBACKWARDS are requested
TESTC_DRIVER(GetRowsetAndAccessor(g_pEmptyTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,guidPropertySet));
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=0. DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_1()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
0, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=1. DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_2()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=-1. DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_3()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL,cRows=0,fSkip=TRUE. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_4()
{
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
0, // # rows to fetch
TRUE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=DBBMK_FIRST,cRows=1. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_5()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_FIRST, cRows=0, DBCOMPAREOPS_IGNORE. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_6()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
// FindNextRows with cRows=0 and pBookmark=non null value is a no-op
// This conforms with IRowsetLocate's behavior with cRows=0.
return CallFindNextRows( g_pEmptyTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
0, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
S_OK, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_LAST,cRows=1. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_7()
{
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=DBBMK_FIRST,cRows=-1. Verify DB_S_ENDOFROWSET
//
// @rdesc TEST_PASS or TEST_FAIL
//
int EmptyRowset::Variation_8()
{
DBBOOKMARK DBBookmark=DBBMK_FIRST;
BYTE *pBookmark=(BYTE *)&DBBookmark;
//restart the cursor position
if(!CHECK(RestartRowPosition(),S_OK))
return TEST_FAIL;
return CallFindNextRows( g_pEmptyTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL EmptyRowset::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(NULL_Collation)
//*-----------------------------------------------------------------------
//| Test Case: NULL_Collation - Test Null collatioans
//| Created: 07/07/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL NULL_Collation::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
if ( g_lNullCollation & DBPROPVAL_NC_END )
{
odtLog<<"NULLs are sorted at the end, regardless of the sort order.\n";
}
else if ( g_lNullCollation & DBPROPVAL_NC_HIGH )
{
odtLog<<"NULLs are sorted at the end\n";
}
else if ( g_lNullCollation & DBPROPVAL_NC_LOW )
{
odtLog<<"NULLs are sorted at the low end\n";
}
else if ( g_lNullCollation & DBPROPVAL_NC_START )
{
odtLog<<"NULLs are sorted at the start of the list, regardless of the sort order\n";
}
else
{
odtLog<<"No Null Collation reported!\n";
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc NE operator with NULL status
//
// @rdesc TEST_PASS or TEST_FAIL
//
int NULL_Collation::Variation_1()
{
BOOL fTestPass = TEST_FAIL;
DBORDINAL ulColIndex = 0;
DBCOUNTITEM cRowsObtained = 0;
HROW hrowNULL = DB_NULL_HROW;
HROW * phrowNULL = &hrowNULL;
HROW hrowNOTNULL = DB_NULL_HROW;
HROW * phrowNOTNULL = &hrowNOTNULL;
CCol TempCol;
CTable * pTable = NULL;
IRowsetIdentity * pIRowsetIden = NULL;
DBPROPID rgPropId[3] = {DBPROP_CANSCROLLBACKWARDS, DBPROP_CANHOLDROWS, DBPROP_IRowsetIdentity};
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(rgPropId), rgPropId));
TESTC(VerifyInterface(m_pIRowset, IID_IRowsetIdentity, ROWSET_INTERFACE,
(IUnknown **)&pIRowsetIden));
for (ulColIndex=1; ulColIndex <= g_pCTable->CountColumnsOnTable(); ulColIndex++)
{
TESTC(SUCCEEDED(m_pIRowset->RestartPosition(NULL)));
g_pCTable->GetColInfo(ulColIndex, TempCol);
if(!CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 0, ulColIndex,
TempCol.GetProviderType(), SUBOP_ALWAYS_NULL))
continue;
TEST2C_(m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, 0,
1, &cRowsObtained, &phrowNULL), S_OK, DB_S_ENDOFROWSET);
ReleaseFindValueAccessor(TempCol.GetProviderType());
if(m_hr == S_OK)
{
// Found a null.
// The next fetch position is after the current cursor position.
// Call FindNextRows with an lOffset of -1 to start finding from
// the row just matched.
//
// This time use a NE operator and a bound value not matching any existing
// value in the column.
// Per spec, using the NE operator never matches a NULL value
// i.e. Finding a value NE to 1 is equivalent to value != 1 and value is not NULL.
TESTC(cRowsObtained == 1);
TESTC(phrowNULL[0] != DB_NULL_HROW);
TESTC(CreateFindValueAccessor(DBCOMPAREOPS_NE, g_pCTable, 0, ulColIndex,
TempCol.GetProviderType(), SUBOP_EMPTY));
TEST2C_(m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_NE, 0, NULL, -1,
1, &cRowsObtained, &phrowNOTNULL), S_OK, DB_S_ENDOFROWSET);
// If end of rowset, that's fine otherwise check that the null value was not matched
if(m_hr == S_OK)
{
TESTC(cRowsObtained == 1);
TESTC(phrowNOTNULL[0] != DB_NULL_HROW);
HRESULT hr = pIRowsetIden->IsSameRow(phrowNULL[0], phrowNOTNULL[0]);
if (hr != S_FALSE)
{
odtLog << L"Failed in column " << ulColIndex << " of type " << TempCol.GetProviderType() << L"\n";
}
CHECK(hr, S_FALSE);
TESTC_(m_pIRowset->ReleaseRows(1, phrowNOTNULL, NULL, NULL, NULL), S_OK);
}
ReleaseFindValueAccessor(TempCol.GetProviderType());
TESTC_(m_pIRowset->ReleaseRows(1, phrowNULL, NULL, NULL, NULL), S_OK);
}
}
fTestPass = TEST_PASS;
CLEANUP:
ReleaseFindValueAccessor(TempCol.GetProviderType());
SAFE_RELEASE(pIRowsetIden);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL NULL_Collation::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Prop_FINDCOMPAREOPS)
//*-----------------------------------------------------------------------
//| Test Case: Prop_FINDCOMPAREOPS - Check DBPROP_FINDCOMAPREOPS
//| Created: 08/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Prop_FINDCOMPAREOPS::Init()
{
DBPROPID guidPropertySet;
ULONG cPrptSet=0;
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
cPrptSet,&guidPropertySet));
CLEANUP:
return TRUE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Check CO_EQUALITY and CO_STRING
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Prop_FINDCOMPAREOPS::Variation_1()
{
DWORD FindOps = 0;
CCol TempCol;
DBORDINAL ulColNum = g_pCTable->CountColumnsOnTable();
DBID *pColDBID = NULL;
for ( ULONG ulColIndex = 1; ulColIndex <= ulColNum; ulColIndex++ )
{
g_pCTable->GetColInfo(ulColIndex, TempCol);
pColDBID = TempCol.GetColID();
FindOps = TC_FindCompareOps( pColDBID );
if ( pColDBID->eKind == DBKIND_NAME )
odtLog << L" Column" << pColDBID->uName.pwszName << L": \n";
// DBPROPVAL_CO_EQUALITY and DBPROPVAL_CO_STRING are required for IRowsetFind
if ( FindOps & DBPROPVAL_CO_EQUALITY )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_EQUALITY\n";
if ( FindOps & DBPROPVAL_CO_STRING )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_STRING\n";
if ( FindOps & DBPROPVAL_CO_CASESENSITIVE )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_CASESENSITIVE\n";
if ( FindOps & DBPROPVAL_CO_CASEINSENSITIVE )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_CASEINSENSITIVE\n";
if ( FindOps & DBPROPVAL_CO_BEGINSWITH )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_BEGINSWITH\n";
if ( FindOps & DBPROPVAL_CO_CONTAINS )
odtLog << L"\t" << L"Supports DBPROPVAL_CO_CONTAINS\n";
}
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Check Case Sensitivity
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Prop_FINDCOMPAREOPS::Variation_2()
{
return TEST_SKIPPED;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Prop_FINDCOMPAREOPS::Terminate()
{
ReleaseRowsetAndAccessor();
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(QueryInt)
//*-----------------------------------------------------------------------
//| Test Case: QueryInt - test queryinterfaces
//| Created: 08/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL QueryInt::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc IRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int QueryInt::Variation_1()
{
BOOL fTestPass = FALSE;
IRowset * pIRowset = NULL;
DBCOUNTITEM cRowsObtained = 0;
HROW hrow[1] = { DB_NULL_HROW };
HROW * phrow = hrow;
if(!TCIRowsetFind::Init())
return FALSE;
//create a rowset and an accessor.
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0, NULL));
TESTC(DefaultObjectTesting(m_pIRowsetFind, ROWSET_INTERFACE));
TESTC(VerifyInterface(m_pIRowsetFind, IID_IRowset, ROWSET_INTERFACE, (IUnknown **)&pIRowset));
TESTC_(pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK);
TESTC(cRowsObtained == 1);
//call VerifyRowPosition
TESTC(VerifyRowPosition(phrow[0],1,g_pCTable));
TESTC_(pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL),S_OK);
fTestPass = TRUE;
CLEANUP:
SAFE_RELEASE(pIRowset);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc IAccessor
//
// @rdesc TEST_PASS or TEST_FAIL
//
int QueryInt::Variation_2()
{
HRESULT hr;
BOOL fTestPass = TRUE;
IRowsetFind * pIRowsetFind = NULL;
IRowset * pIRowset = NULL;
DBCOUNTITEM cRowsObtained;
HROW hrow[1] = { DB_NULL_HROW };
HROW * phrow = hrow;
if( !SetRowsetProperties(NULL, 0) )
goto CLEANUP;
hr = CreateRowsetObject(USE_OPENROWSET, IID_IRowsetFind, EXECUTE_IFNOERROR);
if( hr==DB_S_ERRORSOCCURRED || hr==DB_E_ERRORSOCCURRED )
goto CLEANUP;
TESTC_(hr,S_OK);
TESTC(DefaultObjectTesting(m_pIAccessor, ROWSET_INTERFACE));
//queryinterface for IRowsetFind
TESTC(VerifyInterface(m_pIAccessor, IID_IRowsetFind, ROWSET_INTERFACE, (IUnknown **)&pIRowsetFind));
//queryinterface for IRowset. IRowsetFind implies IRowset
TESTC(VerifyInterface(pIRowsetFind, IID_IRowset, ROWSET_INTERFACE, (IUnknown **)&pIRowset));
//create an accessor on the rowset
TESTC_(GetAccessorAndBindings(pIRowset,DBACCESSOR_ROWDATA,&m_hAccessor,
&m_rgBinding,&m_cBinding,&m_cRowSize,DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,ALL_COLS_BOUND,FORWARD,
NO_COLS_BY_REF,NULL,NULL,NULL,DBTYPE_EMPTY,0,NULL,NULL,
NO_COLS_OWNED_BY_PROV,DBPARAMIO_NOTPARAM,TRUE),S_OK);
//allocate memory for the row
m_pData = PROVIDER_ALLOC(m_cRowSize);
TESTC(m_pData != NULL);
TESTC_(pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK);
TESTC(cRowsObtained == 1);
//call VerifyRowPosition
TESTC(VerifyRowPosition(phrow[0],1,g_pCTable));
TESTC_(pIRowset->ReleaseRows(cRowsObtained, phrow, NULL, NULL, NULL), S_OK);
fTestPass = TRUE;
CLEANUP:
//free the consumer buffer
PROVIDER_FREE(m_pData);
PROVIDER_FREE(m_rgBinding);
PROVIDER_FREE(m_rgTableColOrds);
//free accessor handle
if(m_hAccessor)
{
if(!CHECK(m_pIAccessor->ReleaseAccessor(m_hAccessor,NULL), S_OK))
fTestPass=FALSE;
m_hAccessor=NULL;
}
SAFE_RELEASE(m_pIAccessor);
SAFE_RELEASE(pIRowset);
SAFE_RELEASE(pIRowsetFind);
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//--------------------------------------------------------------------
// @mfunc Use ICmdText
//
// @rdesc TEST_PASS or TEST_FAIL
//
int QueryInt::Variation_3()
{
ICommandText* pICmdText = NULL;
IRowsetFind* pIRowsetFind = NULL;
WCHAR* pwszCmd = NULL;
if (g_pIDBCreateCommand == NULL)
return TEST_SKIPPED;
TESTC_(m_hr = g_pIDBCreateCommand->CreateCommand(NULL, IID_ICommandText, (IUnknown **)&pICmdText), S_OK);
// Get a supported command text
TESTC_(m_hr = g_pCTable->CreateSQLStmt(SELECT_ALLFROMTBL, NULL, &pwszCmd, NULL, NULL), S_OK);
TESTC_(m_hr = pICmdText->SetCommandText(DBGUID_DEFAULT, pwszCmd), S_OK);
// Execute command
TESTC_(m_hr = pICmdText->Execute(NULL, IID_IRowsetFind, NULL, NULL, (IUnknown**) &pIRowsetFind), S_OK);
CLEANUP:
SAFE_FREE(pwszCmd);
SAFE_RELEASE(pICmdText);
SAFE_RELEASE(pIRowsetFind);
return TEST_PASS;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL QueryInt::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCCompareOps_Ignore)
//*-----------------------------------------------------------------------
//| Test Case: TCCompareOps_Ignore - Test specific IGNORE cases
//| Created: 10/02/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCompareOps_Ignore::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc IGNORE w/pBookmark=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCompareOps_Ignore::Variation_1()
{
BOOL fTestPass;
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
HRESULT hrExpected2 = S_OK;
int nRowPos = 8;
// match 3rd row and fetch 2 rows
// new fetch position should be after 4th
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
2, // maps to cRows
2, // maps to Offset
g_ulColNum, // Column to match
3, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
2, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
NULL, // Use client or provider memory, default=provider
TRUE, // verify rows by comparing data ?
FALSE, // Use ISeqStream ?
hrExpected2 // Second expected HRESULT for the FindNextRow step
);
// match 7th row, fetch position should advance 2 rows and be after 7th
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
0, // maps to cRows
2, // maps to Offset
g_ulColNum, // Column to match
7, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
0, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisons are rich enough to deserve a mulitple comparision operations
);
// cursor should be after 7th row.
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phrow[0], nRowPos, g_pCTable), TRUE))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc IGNORE w/ pBookmark = STD_BOOKMARK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCompareOps_Ignore::Variation_2()
{
BOOL fTestPass = TEST_SKIPPED;
DBPROPID guidProperty[1];
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained;
DBBOOKMARK DBBookmark=DBBMK_LAST;
BYTE * pBookmark=(BYTE *)&DBBookmark;
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
guidProperty[0] = DBPROP_IRowsetLocate;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
HRESULT hrExpected2 = S_OK;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
pBookmark, // Bookmark to fetch from, if any
1, // Length of bookmark
1, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
g_lRowLast, // Is there a row where the find should happen? 0 - no match
hrExpected2, // Expected HRESULT
1, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
// make bookmark point to DBBMK_FIRST
DBBookmark=DBBMK_FIRST;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
pBookmark, // Bookmark to fetch from, if any
1, // Length of bookmark
1, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
1, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
1, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
// cursor should be at start of rowset.
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phrow[0], 1, g_pCTable), TRUE))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc IGNORE w/real bookmark
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCompareOps_Ignore::Variation_3()
{
BOOL fTestPass = TEST_SKIPPED;
DBPROPID guidProperty[1];
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained;
ULONG_PTR cbBookmark;
BYTE * pBookmark=NULL;
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
guidProperty[0] = DBPROP_IRowsetLocate;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
1,guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark for the 2th row
if(!GetBookmark(2,&cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
HRESULT hrExpected2 = S_OK;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
pBookmark, // Bookmark to fetch from, if any
cbBookmark, // Length of bookmark
2, // maps to cRows
2, // maps to Offset
g_ulColNum, // Column to match
4, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
2, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
NULL, // Use client or provider memory, default=provider
TRUE, // verify rows by comparing data ?
FALSE, // Use ISeqStream ?
hrExpected2 // Second expected HRESULT for the FindNextRow step
);
HRESULT hrExpected1 = DB_S_ENDOFROWSET;
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
pBookmark, // Bookmark to fetch from, if any
cbBookmark, // Length of bookmark
1, // maps to cRows
g_lRowLast-1, // maps to Offset
g_ulColNum, // Column to match
g_lRowLast, // Is there a row where the find should happen? 0 - no match
hrExpected1, // Expected HRESULT
0, // Expected count of rows
TRUE, // flag to Release rows (optional)
DBCOMPAREOPS_IGNORE, // Any particular preference for comparing? (optional)
SUBOP_EMPTY // Some comparisions are rich enough to deserve a mulitple comparision operations
);
// cursor should be at start of rowset.
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, (HROW **)&phrow ), S_OK) )
goto CLEANUP;
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phrow[0], 1, g_pCTable), TRUE))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(pBookmark);
PROVIDER_FREE(phrow);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCompareOps_Ignore::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(AccessorTests)
//*-----------------------------------------------------------------------
//| Test Case: AccessorTests - Test various accessor variations
//| Created: 02/01/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL AccessorTests::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc obValue = 0, bind VALUE only
//
// @rdesc TEST_PASS or TEST_FAIL
//
int AccessorTests::Variation_1()
{
BOOL fTestPass = TEST_SKIPPED;
DBPROPID guidProperty[1];
HROW * phrow = NULL;
DBCOUNTITEM cRowsObtained;
DBORDINAL ulColToFind;
HRESULT hr;
void *pMakeData = NULL;
CCol TempCol;
DBTYPE wColType;
WCHAR wszData[2000];
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
guidProperty[0] = DBPROP_IRowsetLocate;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
1,guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
goto CLEANUP;
if (!GetVariableLengthStrAndUpdatable(&ulColToFind, DBCOMPAREOPS_EQ))
goto CLEANUP;
fTestPass = TEST_FAIL;
if ( FAILED(m_pTable->GetColInfo(ulColToFind, TempCol)) )
goto CLEANUP;
wColType = TempCol.GetProviderType();
if (wColType==DBTYPE_VARIANT)
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!SUCCEEDED(hr = m_pTable->MakeData( wszData,
1,
ulColToFind,
PRIMARY,
wColType)) )
goto CLEANUP;
if ( hr == S_FALSE )
{
fTestPass = TEST_SKIPPED;
goto CLEANUP; // can't deal with nulls in this variation
}
TESTC(fTestPass=CreateFindValueAccessor(DBCOMPAREOPS_EQ, g_pCTable, 1, ulColToFind, wColType, SUBOP_EMPTY, FALSE, NULL, DBPART_VALUE));
fTestPass = TEST_FAIL;
if ( FAILED( m_hr = m_pIRowsetFind->FindNextRow(DB_NULL_HCHAPTER, m_hRowsetFindAccessor, m_pFindValue,
DBCOMPAREOPS_EQ, 0, NULL, 0,
1, &cRowsObtained, &phrow)) )
goto CLEANUP;
//Verify RowsObtained
if (!COMPARE(cRowsObtained, 1))
goto CLEANUP;
//verify phRow is not NULL
TESTC(phrow!=NULL);
if (!COMPARE(VerifyRowPosition(phrow[0], 1, g_pCTable), TRUE))
goto CLEANUP;
fTestPass = TEST_PASS;
CLEANUP:
//PROVIDER_FREE(pMakeData);
//release the row handle
if(phrow && cRowsObtained>0)
{
CHECK(m_pIRowset->ReleaseRows(cRowsObtained,phrow,NULL,NULL,NULL),S_OK);
PROVIDER_FREE(phrow);
}
ReleaseFindValueAccessor(wColType);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL AccessorTests::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(BindingType)
//*-----------------------------------------------------------------------
//| Test Case: BindingType - Test interesting Find coercions
//| Created: 02/03/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL BindingType::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
CoCreateInstance(CLSID_OLEDB_CONVERSIONLIBRARY,
NULL,
CLSCTX_INPROC_SERVER,
IID_IDataConvert,
(void **)&g_pIDataConvert);
if(!SetDCLibraryVersion((IUnknown *)g_pIDataConvert, g_ulDCVer))
{
odtLog << L"Unable to set Data Conversion Library's behavior version!" << ENDL;
odtLog << L"Need to upgrade to latest MSDADC.DLL." << ENDL;
return TEST_FAIL;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Normal BSTR
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_1()
{
return BindingTypeTest(g_pCTable, DBTYPE_BSTR);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc WSTR
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_2()
{
return BindingTypeTest(g_pCTable, DBTYPE_WSTR);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc STR
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_3()
{
return BindingTypeTest(g_pCTable, DBTYPE_STR);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc VARIANT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_4()
{
return BindingTypeTest(g_pCTable, DBTYPE_VARIANT);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc WSTR | BYREF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_5()
{
return BindingTypeTest(g_pCTable, DBTYPE_WSTR | DBTYPE_BYREF);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc STR | BYREF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_6()
{
return BindingTypeTest(g_pCTable, DBTYPE_STR | DBTYPE_BYREF);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc BSTR | BYREF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_7()
{
return BindingTypeTest(g_pCTable, DBTYPE_BSTR | DBTYPE_BYREF);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc VARIANT BYREF
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BindingType::Variation_8()
{
return BindingTypeTest(g_pCTable, DBTYPE_VARIANT | DBTYPE_BYREF);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL BindingType::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(Deleted_Rows)
//*-----------------------------------------------------------------------
//| Test Case: Deleted_Rows - Test with deleted rows
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Deleted_Rows::Init()
{
BOOL fTestPass = FALSE;
if(!TCIRowsetFind::Init())
return FALSE;
//make sure IID_IRowsetDelete is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetChange].fSupported);
//make sure IID_IRowsetLocate is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
if ( AlteringRowsIsOK() )
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc *pBookMark=last row. Delete last row. Expect DB_E_BADBOOKMARK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_1()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[3];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
//open rowset, and accessor (bind LONG cols)
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (GetProp(DBPROP_BOOKMARKSKIPPED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
//get the bookmark for the last row
if(!GetBookmark(g_lRowLast, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_E_BADBOOKMARK, // HRESULT to verify
0 // How many rows to expect.
);
PopulateTable();
CLEANUP:
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc *pBookMark = 2, cRows=1. Delete 4th row. Match on what was in 4th row. DB_S_ENDOFROWSET and 0 row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_2()
{
int fTestPass=TEST_FAIL;
DBPROPID guidProperty[3];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
//open rowset, and accessor. (bind long cols)
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (GetProp(DBPROP_REMOVEDELETED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(2, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 4), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
4, // row to match
DB_S_ENDOFROWSET,// HRESULT to verify
0 // How many rows to expect.
);
PopulateTable();
CLEANUP:
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc *pBookMark=4, cRows=-1. Delete 1st row. Match on what was in 1st row. DB_S_ENDOFROWSET and 0 row.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_3()
{
int fTestPass=TEST_FAIL;
DBPROPID guidProperty[4];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
guidProperty[3]=DBPROP_CANFETCHBACKWARDS;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (GetProp(DBPROP_REMOVEDELETED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(4, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
-1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
PopulateTable();
CLEANUP:
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pBookMark=NULL, cRows=1. Match 3rd row. Delete third row. pBookmark=NULL, cRows=1, fSkip=0. Match 4th. S_OK, 1 hrow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_4()
{
BOOL fTestPass;
DBPROPID guidProperty[3];
HROW * phRows1 = NULL;
IRowsetChange * pIRowsetChange=NULL;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
phRows1 = (HROW *) PROVIDER_ALLOC(sizeof(HROW));
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
1, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
3, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
1, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if (!fTestPass) goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows1[0], 3, g_pCTable), TRUE))
goto CLEANUP;
//QI for IRowsetChange pointer
if(!CHECK(m_pIRowsetFind->QueryInterface(IID_IRowsetChange,
(void **)&pIRowsetChange),S_OK))
goto CLEANUP;
//delete the row
if(!CHECK(pIRowsetChange->DeleteRows(NULL,1,phRows1,NULL),S_OK))
goto CLEANUP;
if (m_cRowsFound > 0 && phRows1)
{
m_pIRowset->ReleaseRows(m_cRowsFound, phRows1, NULL, NULL, NULL);
if (phRows1 != NULL)
PROVIDER_FREE(phRows1);
}
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
4, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
CLEANUP:
PROVIDER_FREE(phRows1);
SAFE_RELEASE(pIRowsetChange);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows=-1, match 3rd row. Delete 3rd. Match 2nd. S_OK, 1 hrow
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_5()
{
BOOL fTestPass;
DBPROPID guidProperty[4];
HROW * phRows1 = NULL;
IRowsetChange * pIRowsetChange=NULL;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_CANFETCHBACKWARDS;
guidProperty[3]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
phRows1 = (HROW *) PROVIDER_ALLOC(sizeof(HROW));
fTestPass = CallFindNextRows(
g_pCTable, // Table to find from
NULL, // Bookmark to fetch from, if any
0, // Length of bookmark
-1, // maps to cRows
0, // maps to Offset
g_ulColNum, // Column to match
3, // Is there a row where the find should happen? 0 - no match
S_OK, // Expected HRESULT
1, // Expected count of rows
FALSE, // flag to Release rows (optional)
DBCOMPAREOPS_EQ, // Any particular preference for comparing? (optional)
SUBOP_EMPTY, // Some comparisions are rich enough to deserve a mulitple comparision operations
phRows1 // optional arg if client wants to control row handle mem
);
if (!fTestPass) goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows1[0], 3, g_pCTable), TRUE))
goto CLEANUP;
//QI for IRowsetChange pointer
if(!CHECK(m_pIRowsetFind->QueryInterface(IID_IRowsetChange,
(void **)&pIRowsetChange),S_OK))
goto CLEANUP;
//delete the row
if(!CHECK(pIRowsetChange->DeleteRows(NULL,1,phRows1,NULL),S_OK))
goto CLEANUP;
if (m_cRowsFound > 0 && phRows1)
{
m_pIRowset->ReleaseRows(m_cRowsFound, phRows1, NULL, NULL, NULL);
if (phRows1 != NULL)
PROVIDER_FREE(phRows1);
}
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
PopulateTable();
CLEANUP:
PROVIDER_FREE(phRows1);
SAFE_RELEASE(pIRowsetChange);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Delete RowLast-1 row. pBookmark=RowLast-2 row,cRows=3. Match RowLast-2 row.
// Verify S_OK, 3 hrows and DB_E_DELETEDROW when accessing deleted one
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_6()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[4];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW * phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC(3 * sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[3]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(g_lRowLast-2, &cbBookmark, &pBookmark))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (GetProp(DBPROP_REMOVEDELETED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast-1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast-2, // row to match
S_OK, // HRESULT to verify
3, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], g_lRowLast-2, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if (!COMPARE(VerifyRowPosition(phRows[2], g_lRowLast, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if(!CHECK(m_pIRowset->GetData(phRows[1], m_hAccessor, m_pData), DB_E_DELETEDROW))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Delete last row. pBookmark=DBBMK_LAST, cRows=1. Verify DB_E_BADBOOKMARK, 0 rows returned
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Deleted_Rows::Variation_7()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[4];
DBBOOKMARK dbBookMark = DBBMK_LAST;
BYTE *pBookmark = (BYTE *)&dbBookMark;
HROW *phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC(sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[3]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (GetProp(DBPROP_REMOVEDELETED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
GetProp(DBPROP_BOOKMARKSKIPPED)? S_OK : DB_E_BADBOOKMARK, // HRESULT to verify
GetProp(DBPROP_BOOKMARKSKIPPED)? 1 : 0, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phRows);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Deleted_Rows::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(RemoveDeleted)
//*-----------------------------------------------------------------------
//| Test Case: RemoveDeleted - Test in context of RemoveDeleted
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL RemoveDeleted::Init()
{
BOOL fTestPass = TEST_SKIPPED;
if(!TCIRowsetFind::Init())
return FALSE;
//make sure IID_IRowsetDelete is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetChange].fSupported);
//make sure IID_IRowsetLocate is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetLocate].fSupported);
//make sure ScrollBackwards property is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_ScrollBackwards].fSupported);
//make sure IID_IRemoveDeleted is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_RemoveDeleted].fSupported);
if ( AlteringRowsIsOK() )
fTestPass = TRUE;
CLEANUP:
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Delete a row. pBookmark=deleted row. Verify DB_E_BADBOOKMARK.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_1()
{
int fTestPass = TEST_FAIL;;
DBPROPID guidProperty[5];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_REMOVEDELETED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (GetProp(DBPROP_BOOKMARKSKIPPED))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
//get the bookmark for the row 1
if(!GetBookmark(1, &cbBookmark, &pBookmark))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_E_BADBOOKMARK, // HRESULT to verify
0 // How many rows to expect.
);
PopulateTable();
CLEANUP:
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Delete 3rd row. pBookmark=2nd row with cRows=3. Verify S_OK and 2,4,5 hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_2()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[5];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW * phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( 3 * sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_REMOVEDELETED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark for the 2nd row
if(!GetBookmark(2, &cbBookmark, &pBookmark))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 3), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
2, // row to match
S_OK, // HRESULT to verify
3, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], 2, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if (!COMPARE(VerifyRowPosition(phRows[1], 4, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if (!COMPARE(VerifyRowPosition(phRows[2], 5, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Delete RowLast-1 row. pBookmark=RowLast-2 row,cRows=3. Match RowLast-2 row.
// Verify DB_S_ENDOFROWSET and RowLast-2, RowLast hrows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_3()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[5];
BYTE * pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW * phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( 2 * sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_REMOVEDELETED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(g_lRowLast-2, &cbBookmark, &pBookmark))
{
fTestPass = TEST_SKIPPED;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast-1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
3, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast-2, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
2, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], g_lRowLast-2, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if (!COMPARE(VerifyRowPosition(phRows[1], g_lRowLast, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
PROVIDER_FREE(pBookmark);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Delete last row. pBookmark=DBBMK_LAST,cRows=-1. DBCOMPAREOPS_IGNORE. Verify last-1 row returned.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_4()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[5];
DBBOOKMARK dbBookMark = DBBMK_LAST;
BYTE *pBookmark = (BYTE *)&dbBookMark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_REMOVEDELETED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
g_lRowLast-1, // row to match
S_OK, // HRESULT to verify
1, // How many rows to expect.
TRUE, // release rows
DBCOMPAREOPS_IGNORE,
SUBOP_EMPTY,
NULL,
TRUE // check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
CLEANUP:
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc pBookmark=NULL, cRows = 2. match 3rd. Delete 2nd and 5th rows. Find with cRows=-1 and match 3rd
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_5()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[6];
HROW *phRows = NULL;
HROW *phRowsToDelete = NULL;
IRowsetChange *pIRowsetChange = NULL;
DBCOUNTITEM cRowsObtained = 0;
phRows = (HROW *) PROVIDER_ALLOC( sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_REMOVEDELETED;
guidProperty[3]=DBPROP_CANFETCHBACKWARDS;
guidProperty[4]=DBPROP_CANHOLDROWS;
guidProperty[5]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!CHECK(m_pIRowset->GetNextRows(DB_NULL_HCHAPTER, 1, 4, &cRowsObtained, (HROW **)&phRowsToDelete ), S_OK) )
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRowsToDelete[0], 2, g_pCTable), TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRowsToDelete[3], 5, g_pCTable), TRUE))
goto CLEANUP;
if (!CHECK(RestartRowPosition(), S_OK))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
2, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
2 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
//QI for IRowsetChange pointer
if(!CHECK(m_pIRowsetFind->QueryInterface(IID_IRowsetChange,
(void **)&pIRowsetChange),S_OK))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//delete the row
if(!CHECK(pIRowsetChange->DeleteRows(NULL,1,&phRowsToDelete[0],NULL),S_OK))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if(!CHECK(pIRowsetChange->DeleteRows(NULL,1,&phRowsToDelete[3],NULL),S_OK))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
-1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
3, // row to match
S_OK, // HRESULT to verify
1 // How many rows to expect.
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
CLEANUP:
PROVIDER_FREE(phRows);
PROVIDER_FREE(phRowsToDelete);
SAFE_RELEASE(pIRowsetChange);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc *pBookMark = NULL, cRows=1. Delete 4th row. Match on what was in 4th row. DB_S_ENDOFROWSET and 0 rows.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_6()
{
int fTestPass=TEST_FAIL;
DBPROPID guidProperty[4];
BYTE * pBookmark = NULL;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
guidProperty[3]=DBPROP_REMOVEDELETED;
//open rowset, and accessor. (bind long cols)
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 4), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
4, // row to match
DB_S_ENDOFROWSET,// HRESULT to verify
0 // How many rows to expect.
);
PopulateTable();
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc *pBookMark=DBBMK_LAST, cRows=-1. Delete 1st row. Match on what was in 1st row. DB_S_ENDOFROWSET and 0 rows.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RemoveDeleted::Variation_7()
{
int fTestPass=TEST_FAIL;
DBPROPID guidProperty[5];
DBBOOKMARK dbBookMark = DBBMK_LAST;
BYTE *pBookmark = (BYTE *)&dbBookMark;
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_UPDATABILITY;
guidProperty[3]=DBPROP_CANFETCHBACKWARDS;
guidProperty[4]=DBPROP_REMOVEDELETED;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty,DBACCESSOR_ROWDATA, DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, EXECUTE_IFNOERROR, DBTYPE_EMPTY,
TRUE))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
1, // Length of bookmark
-1, // # rows to fetch
0, // Offset
g_ulColNum, // Which column to match
1, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0 // How many rows to expect.
);
CLEANUP:
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL RemoveDeleted::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(BookmarkSkipped)
//*-----------------------------------------------------------------------
//| Test Case: BookmarkSkipped - Test in the context of DBPROP_BOOKMARKSKIPPED
//| Created: 06/18/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL BookmarkSkipped::Init()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID DBPropID=DBPROP_BOOKMARKSKIPPED;
if(!TCIRowsetFind::Init())
return FALSE;
if ( !AlteringRowsIsOK() )
return FALSE;
//make sure IID_IRowsetChange is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_IRowsetChange].fSupported);
//make sure DBPROP_BOOKMARKSKIPPED is supported
TESTC_DRIVER(g_rgDBPrpt[IDX_BookmarkSkipped].fSupported);
//open rowset, and accessor. Request IRowsetChange and IRowsetLocate
TESTC_DRIVER(GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
0,NULL));
//return if the bookmarkskipped is not settable and variant-false
TESTC_DRIVER(GetProp(DBPROP_BOOKMARKSKIPPED))
fTestPass = TRUE;
CLEANUP:
ReleaseRowsetAndAccessor();
return fTestPass;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Delete 1st row. pBookmark=1st row,cRows=5. Match 2nd row. DB_S_ENDOFROWSET(overrides S_BOOKMARKSKIPPED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BookmarkSkipped::Variation_1()
{
BOOL fTestPass = TEST_FAIL;;
DBPROPID guidProperty[5];
BYTE *pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW *phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_BOOKMARKSKIPPED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
goto CLEANUP;
//get the bookmark
if(!GetBookmark(g_lRowLast-1, &cbBookmark, &pBookmark))
goto CLEANUP;
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast-1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
2, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
1, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], g_lRowLast, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Delete last row. pBookmark=last row, cRows=1. Match what was in last row. DB_S_BOOKMARKSKIPPED and no rows retrieved.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BookmarkSkipped::Variation_2()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[5];
BYTE *pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW *phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_BOOKMARKSKIPPED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(g_lRowLast, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, g_lRowLast), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
g_lRowLast, // row to match
DB_S_ENDOFROWSET, // HRESULT to verify
0, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
CLEANUP:
PROVIDER_FREE(phRows);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Delete the first row. pBookmark=1st row,cRows=1. Match 2nd row. DB_S_BOOKMARKSKIPED and 2nd hrow returned.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BookmarkSkipped::Variation_3()
{
BOOL fTestPass = TEST_FAIL;;
DBPROPID guidProperty[5];
BYTE *pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW *phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( 2*sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_BOOKMARKSKIPPED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(1, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 1), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
2, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
2, // row to match
DB_S_BOOKMARKSKIPPED, // HRESULT to verify
2, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], 2, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
if (!COMPARE(VerifyRowPosition(phRows[1], 3, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Delete 3rd row. pBookmark=3rd row,cRows=1. Match 5th row. DB_S_BOOKMARKSKIPPED and one hrow.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int BookmarkSkipped::Variation_4()
{
BOOL fTestPass = TEST_FAIL;
DBPROPID guidProperty[5];
BYTE *pBookmark = NULL;
ULONG_PTR cbBookmark;
HROW *phRows = NULL;
phRows = (HROW *) PROVIDER_ALLOC( sizeof(HROW));
guidProperty[0]=DBPROP_IRowsetChange;
guidProperty[1]=DBPROP_IRowsetLocate;
guidProperty[2]=DBPROP_BOOKMARKSKIPPED;
guidProperty[3]=DBPROP_CANSCROLLBACKWARDS;
guidProperty[4]=DBPROP_UPDATABILITY;
//open rowset, and accessor.
if(!GetRowsetAndAccessor(g_pCTable, SELECT_ORDERBYNUMERIC, IID_IRowsetFind,
NUMELEM(guidProperty),guidProperty))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
//get the bookmark
if(!GetBookmark(3, &cbBookmark, &pBookmark))
{
fTestPass = TEST_FAIL;
goto CLEANUP;
}
if (!COMPARE(DeleteRow(g_pCTable, 3), TRUE))
goto CLEANUP;
fTestPass = CallFindNextRows( g_pCTable, // CTable pointer
pBookmark, // bookmark;
cbBookmark, // Length of bookmark
1, // # rows to fetch
FALSE, // skip current row
g_ulColNum, // Which column to match
5, // row to match
DB_S_BOOKMARKSKIPPED, // HRESULT to verify
1, // How many rows to expect.
FALSE, // Don't release rows
DBCOMPAREOPS_EQ,
SUBOP_EMPTY,
phRows,
FALSE // Don't check row position
);
if (!COMPARE(fTestPass, TRUE))
goto CLEANUP;
if (!COMPARE(VerifyRowPosition(phRows[0], 5, g_pCTable), TRUE))
fTestPass = TEST_FAIL;
CLEANUP:
PROVIDER_FREE(phRows);
ReleaseRowsetAndAccessor();
PopulateTable();
return fTestPass;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL BookmarkSkipped::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCJapanese)
//*-----------------------------------------------------------------------
//| Test Case: TCJapanese - Test scenarios relevant to the JPN locale
//| Created: 1/24/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCJapanese::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCIRowsetFind::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Test case sensitivity and CONTAINS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCJapanese::Variation_1()
{
BOOL fTestPass = TEST_PASS, fSubTestPass = TEST_FAIL;
DBCOUNTITEM cRowsObtained = 0;
DBTYPE wTargetType;
CCol TempCol;
CTable * pTable = NULL;
DBCOUNTITEM cRowsOnTable = 0;
DBCOMPAREOP CompareOp = DBCOMPAREOPS_CONTAINS | DBCOMPAREOPS_CASEINSENSITIVE;
//create the table
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (WCHAR *)g_wszModuleName, NONULLS);
if(!pTable || !SUCCEEDED(pTable->CreateTable(0,1,NULL,PRIMARY,TRUE)))
{
odtLog<<L"Create Table failed, test cannot proceed\n";
SAFE_DELETE(pTable);
return TEST_FAIL;
}
cRowsOnTable = pTable->GetRowsOnCTable();
if (cRowsOnTable != 0)
{
// Delete All Rows
TESTC_(pTable->DeleteRows(), S_OK);
pTable->AddRow(cRowsOnTable);
}
// Insert a row
TESTC_(pTable->Insert(0), S_OK);
//open rowset, and accessor.
TESTC(GetRowsetAndAccessor(pTable, SELECT_ALLFROMTBL, IID_IRowsetFind));
for (DBORDINAL ulColIndex=1; ulColIndex <= pTable->CountColumnsOnTable(); ulColIndex++)
{
TESTC(SUCCEEDED(m_pIRowset->RestartPosition(NULL)));
pTable->GetColInfo(ulColIndex, TempCol);
if (!IsColumnMinimumFindable(&TempCol, CompareOp))
continue;
wTargetType = TempCol.GetProviderType();
if( DBTYPE_STR == wTargetType ||
DBTYPE_WSTR == wTargetType ||
DBTYPE_BSTR == wTargetType)
{
fSubTestPass =
CallFindNextRows
(
pTable, // CTable pointer
NULL, // bookmark;
0, // Length of bookmark
1, // # rows to fetch
0, // offset
ulColIndex, // Which column to match
cRowsOnTable+1, // row to match
S_OK, // HRESULT to verify
1, // How many rows to expect.
TRUE, // Release Rows
CompareOp, // Specifically ask for a compare Op
SUBOP_CONTAINS_BEGIN, // Sub Comparision option
NULL, // Use client or provider memory, default=provider
TRUE // verify rows by comparing data ?
);
if ( fSubTestPass == TEST_FAIL )
{
fTestPass = TEST_FAIL;
odtLog<<"Error at ColName "<< TempCol.GetColName()<<L", ColIndex "<<ulColIndex<<ENDL;
odtLog<<"-------------------------------------------------------------"<< ENDL;
break;
}
}
}
CLEANUP:
ReleaseRowsetAndAccessor();
if (pTable)
{
pTable->DropTable();
SAFE_DELETE(pTable);
}
return fTestPass;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCJapanese::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCIRowsetFind::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
Reference in New Issue View Git Blame Copy Permalink