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

11215 lines
283 KiB
C++
Raw Permalink Blame History

//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright 1995-2000 Microsoft Corporation.
//
// @doc
//
// @module ICOLINFO.CPP | OLE DB IColumnsInfo tests for Provider,
//
#define DBINITCONSTANTS // Must be defined to initialize constants in OLEDB.H
#define INITGUID
#include "modstandard.hpp"
#include "icolinfo.h"
#include "ExtraLib.h"
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0xf17d6f60, 0xd740, 0x11ce, { 0x88, 0xe7, 0x00, 0xaa, 0x00, 0xb5, 0xa9, 0x1b }};
DECLARE_MODULE_NAME("IColumnsInfo");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("The test module for IColumnsInfo interface.");
DECLARE_MODULE_VERSION(795921705);
// TCW_WizardVersion(2)
// TCW_Automation(False)
// }} TCW_MODULE_GLOBALS_END
//Check whether the provider is read only
BOOL g_fReadOnlyProvider = FALSE;
LPCOLESTR g_pwszRowURL=NULL;
LPCOLESTR g_pwszRowsetURL=NULL;
GUID guidMod = { 0xf17d6f60, 0xd740, 0x11ce, { 0x88, 0xe7, 0x00, 0xaa, 0x00, 0xb5, 0xa9, 0x1b }};
//--------------------------------------------------------------------
// @func Module level initialization routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleInit(CThisTestModule * pThisTestModule)
{
// Get connection and session objects
if (ModuleCreateDBSession(pThisTestModule))
{
//Check to see if the DSO is ReadOnly
g_fReadOnlyProvider = GetProperty(DBPROP_DATASOURCEREADONLY, DBPROPSET_DATASOURCEINFO, pThisTestModule->m_pIUnknown);
g_pwszRowURL = NULL;
g_pwszRowsetURL = NULL;
// Create a table we'll use for the whole test module,
// store it in pVoid for now
pThisTestModule->m_pVoid = new CTable(
(IUnknown *)pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
if (!pThisTestModule->m_pVoid)
{
odtLog << wszMemoryAllocationError;
return FALSE;
}
// Start with a table with 5 rows
TERM(FAILED(((CTable *)pThisTestModule->m_pVoid)->CreateTable(5,1,NULL,PRIMARY,TRUE)));
return TRUE;
}
return FALSE;
}
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
// We still own the table since all of our testcases
// have only used it and not deleted it.
if (pThisTestModule->m_pVoid)
{
// Remove table from database
((CTable *)pThisTestModule->m_pVoid)->DropTable();
// Delete CTable object
delete (CTable*)pThisTestModule->m_pVoid;
pThisTestModule->m_pVoid = NULL;
}
return ModuleReleaseDBSession(pThisTestModule);
}
////////////////////////////////////////////////////////////////////////
// TCBase - Class for reusing Test Cases.
// This is one of the base classes from which all the Test Case
// classes will inherit. It is used to duplicate test cases, yet
// maintain some sort of distinct identity for each.
//
////////////////////////////////////////////////////////////////////////
class TCBase
{
public:
//constructor
TCBase() { SetTestCaseParam(TC_Rowset); }
//Set the m_fWarning and m_fBinder flags.
virtual void SetTestCaseParam(ETESTCASE eTestCase = TC_Rowset)
{
m_eTestCase = eTestCase;
switch(eTestCase)
{
case TC_Rowset:
break;
case TC_Cmd:
break;
case TC_OpenRW:
break;
case TC_Bind:
break;
case TC_IColInfo2:
break;
case TC_SingSel:
break;
default:
ASSERT(!L"Unhandled Type...");
break;
};
}
//data
ETESTCASE m_eTestCase;
};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Base Class Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class IColInfo : public CSessionObject, public TCBase
{
public:
// @cmember Which HRESULT should I expect
PREPARATION m_ePreparation;
// @cmember What method
METHOD_CHOICE m_Method;
// @cmember Whether I want to check the structures coming back
BOOL m_fCheckIColumnsInfo;
// @cmember Supported Properties
DBPROPID m_DBPROPID;
// @cmember Count of rows affected, based on non-select statement
DBROWCOUNT m_cRowsAffected;
// @cmember Interface pointers
IDBInitialize * m_pMyIDBInitialize;
IColumnsInfo * m_pIColumnsInfo;
IColumnsInfo2 * m_pIColumnsInfo2;
ICommand * m_pICommand;
IRowset * m_pIRowset;
// @cmember GetColumnInfo params
DBORDINAL m_cColumns;
DBCOLUMNINFO * m_rgInfo;
WCHAR * m_pStringsBuffer;
// @cmember IColumnsInfo2 params
DBORDINAL m_cColumns2;
DBCOLUMNINFO* m_rgInfo2;
DBID * m_rgColumnIDs2;
DBORDINAL m_cMasks;
DBID* m_rgMasks;
BOOL m_fDocSource;
// @cmember MapColumnIDs params
DBORDINAL m_cColumnIDs;
DBID * m_rgColumnIDs;
DBORDINAL* m_rgColumns;
// @cmember Pointer to Row Object
CRowObject* m_pCRowObj;
CRowset* m_pCRowset;
// @cmember CheckProperty
IUnknown * m_pIUnknown;
// @cmember Ordinals of the SQL Statement
DBORDINAL m_cOrdTbl1;
DB_LORDINAL* m_prgOrdTbl1;
DBORDINAL m_cOrdTbl2;
DB_LORDINAL* m_prgOrdTbl2;
// @member HResult
HRESULT m_hr;
// @cmember Constructor
IColInfo(const LPWSTR wszTestCaseName): CSessionObject(wszTestCaseName)
{
// Interface pointer
m_pIColumnsInfo = NULL;
m_pIColumnsInfo2 = NULL;
m_pICommand = NULL;
m_pIRowset = NULL;
m_pMyIDBInitialize = NULL;
m_Method = INVALID_METHOD;
m_fDocSource = FALSE;
m_hr = E_FAIL;
// GetColumnInfo
m_cColumns = 0;
m_rgInfo = NULL;
m_pStringsBuffer = NULL;
m_cColumns2 = 0;
m_rgInfo2 = NULL;
m_rgColumnIDs2 = NULL;
m_cMasks = 0;
m_rgMasks = NULL;
m_pCRowObj = NULL;
m_pCRowset = NULL;
// MapColumnIDs
m_cColumnIDs = 0;
m_rgColumnIDs = NULL;
m_rgColumns = NULL;
m_pIUnknown = NULL;
m_cOrdTbl1 = 0;
m_prgOrdTbl1 = NULL;
m_cOrdTbl2 = 0;
m_prgOrdTbl2 = NULL;
};
// @cmember Destructor
virtual ~IColInfo()
{
// Interface pointer
ASSERT(!m_pIColumnsInfo);
ASSERT(!m_pIColumnsInfo2);
ASSERT(!m_pICommand);
ASSERT(!m_pIRowset);
// GetColumnInfo
ASSERT(!m_rgInfo);
ASSERT(!m_pStringsBuffer);
ASSERT(!m_rgInfo2);
ASSERT(!m_rgColumnIDs2);
ASSERT(!m_rgMasks);
ASSERT(!m_pCRowObj);
ASSERT(!m_pCRowset);
// MapColumnIDs
ASSERT(!m_rgColumnIDs);
ASSERT(!m_rgColumns);
};
// @cmember Test case Init
BOOL Init(EINTERFACE eInterface);
// @cmember Test case Terminate
BOOL Terminate();
// @cmember GetDBIDs copies dbids form DBCOLUMNINFO structure and makes
// param to pass to MapColIDs
HRESULT GetDBIDs(
BOOL fcColumnIDs=TRUE,
BOOL frgColumnIDs=TRUE,
BOOL frgColumns=TRUE,
ULONG cExpectedRuns=1,
BOOL fPrep = TRUE
);
// @cmember MakeDBIDArrays copies dbids form DBCOLUMNINFO structure and makes
// param to pass to MapColIDs
HRESULT MakeDBIDArrays(
BOOL fcColumnIDs=TRUE,
BOOL frgColumnIDs=TRUE,
BOOL frgColumns=TRUE
);
// @cmember Compare Ordinal to CCol
BOOL CheckOrdinal(HRESULT hr, BOOL bCheckOrder=TRUE);
// @cmember Check HResult
BOOL IfErrorParmsShouldBeNULL();
// @cmember Check Correctness of each column
void CheckEachColumn(HRESULT hr,DBPROPID PropID=0,EQUERY eSQLStmt=NO_QUERY);
// @cmember Variation-specific initialization
BOOL Init_Var();
// @cmember Variation-specific initialization
BOOL Free(BOOL fFreeIColInfo=TRUE);
// @cmember Free the IColumnsInfo buffers
BOOL FreeColumnInfo(DBORDINAL* pcColumns,DBCOLUMNINFO** prgInfo, OLECHAR** pStringsBuffer);
// @cmember Executes MapColumnIDs on a rowset object
HRESULT ExecuteMethod_row(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns,
STATEMENTKIND StmtKd,
EQUERY sqlStmt,
WCHAR * pStmt,
EPREPARE ePrepare,
ULONG cExpectedRuns=1,
DBPROPID prop=0
);
// @cmember Executes MapClumnIDs on a command object
HRESULT ExecuteMethod_cmd(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns,
STATEMENTKIND StmtKd,
EQUERY sqlStmt,
WCHAR * pStmt,
EPREPARE ePrepare,
ULONG cExpectedRuns=1,
DBPROPID prop=0,
BOOL fSingSel=FALSE
);
// @cmember Obtains a row object from a rowset.
BOOL GetRowFromRowset(BOOL bColInfo2);
// @cmember Obtains a row object from a command.
BOOL GetRowFromCommand(BOOL bColInfo2);
// @cmember Obtains a row object from OpenRowset.
BOOL GetRowFromOpenRW(BOOL bColInfo2);
// @cmember Obtains a row object by direct binding.
BOOL GetRowFromBind(BOOL bColInfo2);
//Get IColumnsInfo interface on Row object
BOOL GetRowIColumnsInfo(ICommand* pIC, IUnknown** pICI);
// @cmember Calls a method on the row object in m_pCRowObj.
HRESULT CallMethodOnRowObj(BOOL bColInfo2, METHOD_CHOICE method=INVALID_METHOD);
// @cmember Checks the returned values of output params.
BOOL CheckParams(HRESULT hr, METHOD_CHOICE method);
// @cmember Checks the row specific columns returned by calls
// on a Row object.
BOOL CheckRowSpecificColumns(DBORDINAL cCols, DBCOLUMNINFO* rgInfo, DBORDINAL ulFirstOrd);
// @cmember Checks the returned columns to see if the restrictions
//were applied.
BOOL VerifyRestrictions();
// compare the DBCOLUMNINFO struct except for:
BOOL Compare_pwszName(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt);
BOOL Compare_pTypeInfo(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_iOrdinal(DBORDINAL iOrdinal,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_ulColumnSize(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_dwType(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_bPrecision(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_bScale(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_Columnid(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt);
BOOL Compare_DBCOLUMNFLAGS_CACHEDEFERRED(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISBOOKMARK(DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISFIXEDLENGTH(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISLONG(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISNULLABLE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISROWID(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_ISROWVER(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_MAYBENULLABLE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt);
BOOL Compare_DBCOLUMNFLAGS_MAYDEFER(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
BOOL Compare_DBCOLUMNFLAGS_WRITE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex);
void PrintInfo(DBCOLUMNINFO * dbColumnInfo, DBORDINAL ulIndex);
BOOL GetPreparation();
void SetRowsetProperties(GUID propset, DBPROPID propid);
};
void IColInfo::SetRowsetProperties(GUID propset, DBPROPID propid)
{
//Set properties for rowsets
DBPROP * rgDBProps;
rgDBProps = (DBPROP *)PROVIDER_ALLOC(sizeof(DBPROP) * 1);
rgDBProps->dwPropertyID = propid;
rgDBProps->dwOptions = DBPROPOPTIONS_REQUIRED;
rgDBProps->vValue.vt = VT_BOOL;
V_BOOL(&(rgDBProps->vValue)) = VARIANT_TRUE;
//Build the Set struct to set all our rowset properties
m_cPropSets = 1;
m_rgPropSets = (DBPROPSET *)PROVIDER_ALLOC(m_cPropSets * sizeof(DBPROPSET));
m_rgPropSets->rgProperties = rgDBProps;
m_rgPropSets->rgProperties->colid = DB_NULLID;
m_rgPropSets->cProperties = 1;
m_rgPropSets->guidPropertySet = propset;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetPreparation
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetPreparation()
{
BOOL fSucceed = FALSE;
ICommand * pICommand = NULL;
ICommandPrepare * pICommandPrepare = NULL;
// Initialize
m_ePreparation = NOTSUPPORTED;
// Check for Command Support
if (!m_pIDBCreateCommand)
return TRUE;
if (FAILED(m_pIDBCreateCommand->CreateCommand(NULL,IID_ICommand,(IUnknown **)&pICommand)))
return FALSE;
if (SUCCEEDED(pICommand->QueryInterface(IID_ICommandPrepare,(void **)&pICommandPrepare)))
m_ePreparation = SUPPORTED;
fSucceed = TRUE;
SAFE_RELEASE(pICommand);
SAFE_RELEASE(pICommandPrepare);
return fSucceed;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// PrintInfo
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void IColInfo::PrintInfo(DBCOLUMNINFO * dbColumnInfo, DBORDINAL ulIndex)
{
odtLog <<L"[" <<ulIndex <<L"] -> pwszName = " <<dbColumnInfo[ulIndex].pwszName <<ENDL;
odtLog <<L"[" <<ulIndex <<L"] -> iOrdinal = " <<dbColumnInfo[ulIndex].iOrdinal <<ENDL;
odtLog <<L"[" <<ulIndex <<L"] -> ulColumnSize = " <<dbColumnInfo[ulIndex].ulColumnSize <<ENDL;
odtLog <<L"[" <<ulIndex <<L"] -> wType = " <<dbColumnInfo[ulIndex].wType <<ENDL;
odtLog <<L"[" <<ulIndex <<L"] -> bPrecision = " <<dbColumnInfo[ulIndex].bPrecision <<ENDL;
odtLog <<L"[" <<ulIndex <<L"] -> bScale = " <<dbColumnInfo[ulIndex].bScale <<ENDL;
odtLog <<L"Flag that are supported are : " <<ENDL;
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_CACHEDEFERRED) odtLog <<L"CACHEDEFERRED ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISBOOKMARK) odtLog <<L"ISBOOKMARK ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISFIXEDLENGTH) odtLog <<L"ISFIXEDLENGTH ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISLONG) odtLog <<L"ISLONG ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISNULLABLE) odtLog <<L"ISNULLABLE ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISROWID) odtLog <<L"ISROWID ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ISROWVER) odtLog <<L"ISROWVER ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_MAYBENULL) odtLog <<L"MAYBENULL ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_MAYDEFER) odtLog <<L"MAYDEFER ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_WRITE) odtLog <<L"WRITE ";
if (dbColumnInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_WRITEUNKNOWN) odtLog <<L"WRITEUNKNOWN";
odtLog <<ENDL;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Init
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::Init(EINTERFACE eInterface)
{
WCHAR * pwszColList=NULL;
if (COLEDB::Init())
{
// Have this testcase use the table created in ModuleInit, but don't
// let table be deleted, since we'll use it for next test case
SetTable((CTable *)m_pThisTestModule->m_pVoid, DELETETABLE_NO);
// Create a second table for the Join variations
m_pTable2 = new CTable((IUnknown *)m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
if (!SUCCEEDED(m_pTable2->CreateTable(0,1,NULL,PRIMARY,TRUE)))
return FALSE;
m_cOrdTbl2 = m_pTable2->CountColumnsOnTable();
if(m_cOrdTbl2)
{
m_pTable2->CreateColList(FORWARD, &pwszColList, &m_cOrdTbl2, &m_prgOrdTbl2);
PROVIDER_FREE(pwszColList);
}
// Set DSO pointer
if (m_pThisTestModule->m_pIUnknown)
{
if(!VerifyInterface(m_pThisTestModule->m_pIUnknown, IID_IDBInitialize, DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBInitialize))
return FALSE;
}
if (m_pIDBInitialize)
m_pMyIDBInitialize = m_pIDBInitialize;
// Create Data Source Object, Initialize, and get a IOpenRowset pointer.
SetDBSession(m_pThisTestModule->m_pIUnknown2);
// Fill in the Ordinals
if (eInterface == ROWSET_INTERFACE)
{
m_cOrdTbl1 = m_pTable->CountColumnsOnTable();
if(m_cOrdTbl1)
{
m_pTable->CreateColList(FORWARD, &pwszColList, &m_cOrdTbl1, &m_prgOrdTbl1);
PROVIDER_FREE(pwszColList);
}
}
// Make sure base classes are working
if ((!m_pIDBCreateCommand) && (eInterface == COMMAND_INTERFACE))
{
odtLog << L"Commands not supported by Provider." << ENDL;
return TEST_SKIPPED;
}
if (!GetPreparation())
return FALSE;
return TRUE;
}
return FALSE;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Terminate
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::Terminate()
{
COLEDB::Terminate();
SAFE_RELEASE(m_pIDBInitialize);
PROVIDER_FREE(m_prgOrdTbl1);
PROVIDER_FREE(m_prgOrdTbl2);
m_cOrdTbl1 = 0;
m_cOrdTbl2 = 0;
// Drop the second table
if(m_pTable2)
CHECK(m_pTable2->DropTable(),S_OK);
SAFE_DELETE(m_pTable2);
// Release session object
ReleaseDBSession();
SAFE_DELETE(m_pCRowObj);
SAFE_DELETE(m_pCRowset);
return(CTestCases::Terminate());
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Init, inorder to clear properties, need to get rid of ICommand object
// and get new ICommand Object
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::Init_Var()
{
// Don't check columninfo by default
m_fCheckIColumnsInfo = TRUE;
// Reset Params
m_cRowsAffected = 0;
m_cColumns = 0;
m_DBPROPID = 0;
m_cColumnIDs = 0;
m_cPropSets = 0;
m_rgPropSets = NULL;
m_hr = E_FAIL;
// Check for Commands
if (m_pIDBCreateCommand)
if (FAILED(m_pIDBCreateCommand->CreateCommand(NULL,IID_ICommand,(IUnknown **)&m_pICommand)))
return FALSE;
// Initialize to the Command Object
m_pIUnknown = m_pICommand;
return TRUE;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Free_
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::Free(BOOL fFreeIColInfo)
{
// Release
if(fFreeIColInfo)
{
SAFE_RELEASE(m_pIColumnsInfo);
SAFE_RELEASE(m_pIColumnsInfo2);
}
SAFE_RELEASE(m_pIRowset);
SAFE_RELEASE(m_pICommand);
if (m_rgInfo == INVALID(DBCOLUMNINFO*))
m_rgInfo = NULL;
if (m_rgInfo2 == INVALID(DBCOLUMNINFO*))
m_rgInfo2 = NULL;
if (m_pStringsBuffer == INVALID(WCHAR*))
m_pStringsBuffer = NULL;
if (m_rgColumnIDs2!=INVALID(DBID*))
SAFE_FREE(m_rgColumnIDs2)
else
m_rgColumnIDs2 = NULL;
if (m_rgColumns!=INVALID(DBORDINAL*))
SAFE_FREE(m_rgColumns)
else
m_rgColumns = NULL;
if (m_rgColumnIDs!=INVALID(DBID*))
SAFE_FREE(m_rgColumnIDs)
else
m_rgColumnIDs = NULL;
if (m_rgMasks!=INVALID(DBID*))
SAFE_FREE(m_rgMasks)
else
m_rgMasks = NULL;
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
FreeColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
FreeProperties(&m_cPropSets, &m_rgPropSets);
return TRUE;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Free_
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::FreeColumnInfo(DBORDINAL* pcColumns,DBCOLUMNINFO** prgInfo, OLECHAR** pStringsBuffer)
{
TBEGIN;
// Check to see if we need to free the buffer
if( prgInfo )
SAFE_FREE(*prgInfo);
if( pStringsBuffer )
SAFE_FREE(*pStringsBuffer);
return TRUE;
}
/// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// ExecuteMethod_row
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
HRESULT IColInfo::ExecuteMethod_row
(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns,
STATEMENTKIND StmtKd,
EQUERY sqlStmt,
WCHAR * pStmt,
EPREPARE ePrepare,
ULONG cExpectedRuns,
DBPROPID prop
)
{
HRESULT hr = E_FAIL;
IID riid = IID_IRowset;
// Make sure we cleanup
SAFE_RELEASE(m_pIColumnsInfo);
PROVIDER_FREE(m_prgOrdTbl1);
m_cOrdTbl1 = 0;
// SetText
if (FAILED(hr=SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
StmtKd,sqlStmt,pStmt,&m_cOrdTbl1,&m_prgOrdTbl1)))
goto CLEANUP;
// Set property if writable
if (SettableProperty(prop, DBPROPSET_ROWSET, m_pIDBInitialize))
CHECK(hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop),S_OK);
else
{
// If the Property is ReadOnly and the value is the same exp. S_OK
if (GetProperty(prop, DBPROPSET_ROWSET, m_pICommand))
CHECK(hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop),S_OK);
else
{
hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop);
if(SUCCEEDED(hr))
{
CHECKW(hr, DB_E_ERRORSOCCURRED);
odtLog <<wszPropertySet;
}
else
CHECK(hr, DB_E_ERRORSOCCURRED);
}
}
if (m_Method == MAPCOLID)
{
if (FAILED(hr=GetDBIDs(fcColumnIDs,frgColumnIDs,frgColumns,cExpectedRuns)))
goto CLEANUP;
}
// Prepare the Statement
if ((m_ePreparation == SUPPORTED) &&
(FAILED(hr=PrepareCommand(m_pICommand,PREPARE,cExpectedRuns))))
goto CLEANUP;
if (FAILED(hr=m_pICommand->Execute(NULL,riid,NULL,
&m_cRowsAffected,(IUnknown **) &m_pIRowset)))
goto CLEANUP;
if (FAILED(hr=m_pIRowset->QueryInterface(IID_IColumnsInfo,(void **)&m_pIColumnsInfo)))
goto CLEANUP;
if (m_Method == GETCOLINFO)
return hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,&m_rgInfo,&m_pStringsBuffer);
else if (m_Method == MAPCOLID)
return hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,m_rgColumns);
CLEANUP:
odtLog << wszTestFailure;
return hr;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// ExecuteMethod_cmd
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
HRESULT IColInfo::ExecuteMethod_cmd
(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns,
STATEMENTKIND StmtKd,
EQUERY sqlStmt,
WCHAR * pStmt,
EPREPARE ePrepare,
ULONG cExpectedRuns,
DBPROPID prop,
BOOL fSingSel
)
{
HRESULT hr = E_FAIL;
// Make sure we cleanup
SAFE_RELEASE(m_pIColumnsInfo);
PROVIDER_FREE(m_prgOrdTbl1);
m_cOrdTbl1 = 0;
// ICommandText::SetCommandText
if (FAILED(hr=SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
StmtKd,sqlStmt,pStmt,&m_cOrdTbl1,&m_prgOrdTbl1)))
goto CLEANUP;
// Set property if writable
if(prop)
{
if (SettableProperty(prop, DBPROPSET_ROWSET, m_pIDBInitialize))
CHECK(hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop),S_OK);
else
{
// If the Property is ReadOnly and the value is the same exp. S_OK
if (GetProperty(prop, DBPROPSET_ROWSET, m_pICommand))
CHECK(hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop),S_OK);
else
{
hr=SetRowsetProperty(m_pICommand,DBPROPSET_ROWSET,prop);
if(SUCCEEDED(hr))
{
CHECKW(hr, DB_E_ERRORSOCCURRED);
odtLog <<wszPropertySet;
}
else
CHECK(hr, DB_E_ERRORSOCCURRED);
}
}
}
// Get an IColumnsInfo pointer
if(fSingSel)
{
TESTC(GetRowIColumnsInfo(m_pICommand, (IUnknown**)&m_pIColumnsInfo))
}
else
{
//Get IColumnsInfo off the command object
if (FAILED(hr=m_pICommand->QueryInterface(IID_IColumnsInfo,(void **) &m_pIColumnsInfo)))
goto CLEANUP;
}
if (m_Method == MAPCOLID)
{
if (FAILED(hr=GetDBIDs(fcColumnIDs,frgColumnIDs,frgColumns,cExpectedRuns, !fSingSel)))
goto CLEANUP;
}
// Prepare the Statement
if ((m_ePreparation == SUPPORTED) && (!fSingSel) &&
(FAILED(hr=PrepareCommand(m_pICommand,ePrepare,cExpectedRuns))))
goto CLEANUP;
if (m_Method == GETCOLINFO)
{
hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,&m_rgInfo,&m_pStringsBuffer);
if(SUCCEEDED(hr))
{
// Adjust the column count for Joins
if((sqlStmt == SELECT_LEFTOUTERJOIN) || (sqlStmt == SELECT_RIGHTOUTERJOIN))
COMPARE(m_cColumns, DBORDINAL((m_cOrdTbl1 + m_cOrdTbl2) + (m_cColumns ? !m_rgInfo[0].iOrdinal : 0)));
else
COMPARE(m_cColumns, DBORDINAL(m_cOrdTbl1 + (m_cColumns ? !m_rgInfo[0].iOrdinal : 0)));
}
}
else if (m_Method == MAPCOLID)
hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,m_rgColumns);
else
hr=E_FAIL;
CLEANUP:
return hr;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetRowFromRowset
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetRowFromRowset(BOOL bColInfo2)
{
TBEGIN
HRESULT hr = E_FAIL;
BOOL bRowSup = FALSE;
ULONG_PTR ulOleObj = 0;
ULONG_PTR ulDSType = 0;
DBCOUNTITEM cRowsObtained = 0;
HROW* rghRows = NULL;
//Required for using some ExtraLib functions.
g_pIDBInitialize = m_pIDBInitialize;
g_pIOpenRowset = m_pIOpenRowset;
//Check if provider supports ROW Objects. If not, then SKIP
//this test case.
if(GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulOleObj))
{
if((ulOleObj & DBPROPVAL_OO_ROWOBJECT) == DBPROPVAL_OO_ROWOBJECT)
bRowSup = TRUE;
}
if(GetProperty(DBPROP_DATASOURCE_TYPE, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulDSType))
{
if(ulDSType & DBPROPVAL_DST_DOCSOURCE)
m_fDocSource = TRUE;
}
m_pCRowset = new CRowset();
//Create the parent Rowset of the row objects used for testing
//in the variations.
m_pCRowset->SetProperty(DBPROP_CANHOLDROWS);
m_pCRowset->SetProperty(DBPROP_IRowsetIdentity);
m_pCRowset->SetSettableProperty(DBPROP_IRowsetLocate);
TESTC_(m_pCRowset->CreateRowset(USE_OPENROWSET, IID_IRowset, m_pTable),S_OK);
TESTC_(m_pCRowset->RestartPosition(),S_OK)
TESTC_(m_pCRowset->GetNextRows(0, 1, &cRowsObtained, &rghRows),S_OK)
m_pCRowObj = new CRowObject();
TEST3C_(hr = m_pCRowObj->CreateRowObject(m_pCRowset->pIRowset(),
rghRows[0]), S_OK, DB_S_NOROWSPECIFICCOLUMNS, E_NOINTERFACE)
if(bRowSup)
TEST2C_(hr, S_OK, DB_S_NOROWSPECIFICCOLUMNS)
else
{
if(E_NOINTERFACE == hr)
TESTC_PROVIDER(FALSE) // ROW objects are not supported.
else
COMPAREW(FAILED(hr), TRUE);
}
if(bColInfo2)
TESTC_PROVIDER(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo2,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo2))
else
TESTC(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo))
TESTC(VerifyInterface(m_pCRowset->pIRowset(), IID_IUnknown,
ROWSET_INTERFACE, (IUnknown**)&m_pIUnknown))
CLEANUP:
SAFE_FREE(rghRows);
TRETURN
} //GetRowFromRowset
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetRowFromCommand
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetRowFromCommand(BOOL bColInfo2)
{
TBEGIN
HRESULT hr = E_FAIL;
BOOL bRowSup = FALSE;
ULONG_PTR ulOleObj = 0;
ULONG_PTR ulDSType = 0;
DBROWCOUNT cRowsAffected = 0;
IRow* pIRow = NULL;
//Required for using some ExtraLib functions.
g_pIDBInitialize = m_pIDBInitialize;
g_pIOpenRowset = m_pIOpenRowset;
//Check if provider supports ROW Objects. If not, then SKIP
//this test case.
if(GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulOleObj))
{
if((ulOleObj & DBPROPVAL_OO_SINGLETON) == DBPROPVAL_OO_SINGLETON)
bRowSup = TRUE;
}
if(GetProperty(DBPROP_DATASOURCE_TYPE, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulDSType))
{
if(ulDSType & DBPROPVAL_DST_DOCSOURCE)
m_fDocSource = TRUE;
}
TESTC_PROVIDER(m_pIDBCreateCommand)
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL,IID_ICommand,
(IUnknown **)&m_pICommand), S_OK)
// SetText
TESTC_(SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
eSELECT,SELECT_ALLFROMTBL,NULL,&m_cOrdTbl1,&m_prgOrdTbl1), S_OK)
// Prepare the Statement
if (m_ePreparation == SUPPORTED)
TESTC_(PrepareCommand(m_pICommand,PREPARE,1), S_OK)
TEST3C_(hr = m_pICommand->Execute(NULL,IID_IRow,NULL, &cRowsAffected,
(IUnknown **) &pIRow), S_OK, DB_S_NOTSINGLETON, E_NOINTERFACE)
if(bRowSup)
TEST2C_(hr, S_OK, DB_S_NOTSINGLETON)
else
{
if(E_NOINTERFACE == hr)
TESTC_PROVIDER(FALSE) // ROW objects are not supported.
else
COMPAREW(FAILED(hr), TRUE);
}
m_pCRowObj = new CRowObject();
TESTC_(m_pCRowObj->SetRowObject(pIRow), S_OK)
if(bColInfo2)
TESTC_PROVIDER(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo2,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo2))
else
TESTC(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo))
TESTC(VerifyInterface(m_pICommand, IID_IUnknown,
COMMAND_INTERFACE, (IUnknown**)&m_pIUnknown))
CLEANUP:
SAFE_RELEASE(pIRow);
SAFE_RELEASE(m_pICommand);
TRETURN
} //GetRowFromCommand
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetRowFromOpenRW
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetRowFromOpenRW(BOOL bColInfo2)
{
TBEGIN
HRESULT hr = E_FAIL;
BOOL bRowSup = FALSE;
ULONG_PTR ulOleObj = 0;
ULONG_PTR ulDSType = 0;
DBROWCOUNT cRowsAffected = 0;
IRow* pIRow = NULL;
//Required for using some ExtraLib functions.
g_pIDBInitialize = m_pIDBInitialize;
g_pIOpenRowset = m_pIOpenRowset;
//Check if provider supports ROW Objects. If not, then SKIP
//this test case.
if(GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulOleObj))
{
if((ulOleObj & DBPROPVAL_OO_SINGLETON) == DBPROPVAL_OO_SINGLETON)
bRowSup = TRUE;
}
if(GetProperty(DBPROP_DATASOURCE_TYPE, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulDSType))
{
if(ulDSType & DBPROPVAL_DST_DOCSOURCE)
m_fDocSource = TRUE;
}
TEST3C_(hr = m_pIOpenRowset->OpenRowset(NULL, &(m_pTable->GetTableID()),
NULL, IID_IRow, 0, NULL, (IUnknown **) &pIRow), S_OK, DB_S_NOTSINGLETON, E_NOINTERFACE)
if(bRowSup)
TEST2C_(hr, S_OK, DB_S_NOTSINGLETON)
else
{
if(E_NOINTERFACE == hr)
TESTC_PROVIDER(FALSE) // ROW objects are not supported.
else
COMPAREW(FAILED(hr), TRUE);
}
m_pCRowObj = new CRowObject();
TESTC_(m_pCRowObj->SetRowObject(pIRow), S_OK)
if(bColInfo2)
TESTC_PROVIDER(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo2,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo2))
else
TESTC(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo))
TESTC_(hr = m_pIOpenRowset->OpenRowset(NULL, &(m_pTable->GetTableID()),
NULL, IID_IRowset, 0, NULL, (IUnknown **) &m_pIUnknown), S_OK)
CLEANUP:
SAFE_RELEASE(pIRow);
SAFE_RELEASE(m_pICommand);
TRETURN
} //GetRowFromOpenRW
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetRowFromBind
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetRowFromBind(BOOL bColInfo2)
{
TBEGIN
HRESULT hr = E_FAIL;
BOOL bRowSup = FALSE;
ULONG_PTR ulOleObj = 0;
ULONG_PTR ulDSType = 0;
ULONG cPropSets = 0;
DBPROPSET* rgPropSets = NULL;
DBROWCOUNT cRowsAffected = 0;
IRow* pIRow = NULL;
IBindResource* pIBR = NULL;
IDBBinderProperties* pIDBBP = NULL;
//Required for using some ExtraLib functions.
g_pIDBInitialize = m_pIDBInitialize;
g_pIOpenRowset = m_pIOpenRowset;
//Check if provider supports direct binding.
TESTC_PROVIDER(GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulOleObj) &&
((ulOleObj & DBPROPVAL_OO_DIRECTBIND) == DBPROPVAL_OO_DIRECTBIND))
//Check if provider supports ROW Objects. If not, then SKIP
//this test case.
if((ulOleObj & DBPROPVAL_OO_ROWOBJECT) == DBPROPVAL_OO_ROWOBJECT)
bRowSup = TRUE;
if(GetProperty(DBPROP_DATASOURCE_TYPE, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulDSType))
{
if(ulDSType & DBPROPVAL_DST_DOCSOURCE)
m_fDocSource = TRUE;
}
if(GetModInfo()->GetRootBinder())
{
TESTC_PROVIDER(VerifyInterface(GetModInfo()->GetRootBinder(), IID_IBindResource,
BINDER_INTERFACE, (IUnknown**)&pIBR))
TESTC(VerifyInterface(pIBR, IID_IDBBinderProperties,
BINDER_INTERFACE, (IUnknown**)&pIDBBP))
TESTC(GetInitProps(&cPropSets, &rgPropSets))
TESTC_(pIDBBP->SetProperties(cPropSets, rgPropSets), S_OK)
}
else
{
TESTC_PROVIDER(VerifyInterface(m_pIOpenRowset, IID_IBindResource,
SESSION_INTERFACE, (IUnknown**)&pIBR))
}
if(!g_pwszRowURL)
{
g_pwszRowURL = GetModInfo()->GetParseObject()->GetURL(ROW_INTERFACE);
if(!g_pwszRowURL)
g_pwszRowURL = GetModInfo()->GetRootURL();
}
if(!g_pwszRowsetURL)
{
g_pwszRowsetURL = GetModInfo()->GetParseObject()->GetURL(ROWSET_INTERFACE);
if(!g_pwszRowsetURL)
g_pwszRowsetURL = GetModInfo()->GetRootURL();
}
TESTC_PROVIDER(g_pwszRowsetURL && wcslen(g_pwszRowsetURL)>3)
TEST2C_(hr = pIBR->Bind(NULL, g_pwszRowURL, DBBINDURLFLAG_READ, DBGUID_ROW,
IID_IRow, NULL, NULL, NULL, (IUnknown**)&pIRow), S_OK, DB_E_NOTSUPPORTED)
if(bRowSup)
{
TESTC_(hr, S_OK)
TESTC(pIRow != NULL)
}
else
{
if(DB_E_NOTSUPPORTED == hr)
TESTC_PROVIDER(FALSE) // ROW objects are not supported.
else
COMPAREW(FAILED(hr), TRUE);
}
TESTC_(pIBR->Bind(NULL, g_pwszRowsetURL, DBBINDURLFLAG_READ, DBGUID_ROWSET,
IID_IUnknown, NULL, NULL, NULL, (IUnknown**)&m_pIUnknown), S_OK)
TESTC(m_pIUnknown != NULL)
m_pCRowObj = new CRowObject();
TESTC_(m_pCRowObj->SetRowObject(pIRow), S_OK)
if(bColInfo2)
TESTC_PROVIDER(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo2,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo2))
else
TESTC(VerifyInterface(m_pCRowObj->pIRow(), IID_IColumnsInfo,
ROW_INTERFACE, (IUnknown**)&m_pIColumnsInfo))
CLEANUP:
FreeProperties(&cPropSets, &rgPropSets);
SAFE_RELEASE(pIDBBP);
SAFE_RELEASE(pIRow);
SAFE_RELEASE(pIBR);
TRETURN
} //GetRowFromBind
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// CallMethodOnRowObj
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::GetRowIColumnsInfo(ICommand* pIC, IUnknown** ppICI)
{
TBEGIN
IRow* pIRow = NULL;
TESTC(pIC && ppICI)
//Get IColumnsInfo off the row object
if(m_ePreparation == SUPPORTED)
TESTC(SUCCEEDED(PrepareCommand(pIC,PREPARE,0)))
TESTC(SUCCEEDED(pIC->Execute(NULL, IID_IRow, NULL, NULL, (IUnknown**)&pIRow)))
TESTC(VerifyInterface(pIRow, IID_IColumnsInfo, ROW_INTERFACE, (IUnknown**)ppICI))
CLEANUP:
SAFE_RELEASE(pIRow);
TRETURN
} //GetRowIColumnsInfo
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// CallMethodOnRowObj
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
HRESULT IColInfo::CallMethodOnRowObj(BOOL bColInfo2, METHOD_CHOICE method)
{
HRESULT hr = E_FAIL;
METHOD_CHOICE methodused = INVALID_METHOD;
TESTC(m_pCRowObj != NULL)
if(method==INVALID_METHOD)
methodused = m_Method;
else
methodused = method;
switch (methodused)
{
case GETCOLINFO:
if(bColInfo2)
hr = m_pIColumnsInfo2->GetColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
else
hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
break;
case MAPCOLID:
if(bColInfo2)
hr = m_pIColumnsInfo2->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,m_rgColumns);
else
hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,m_rgColumns);
break;
case GETRESCOLINFO:
hr = m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks, 0, &m_cColumns2,&m_rgColumnIDs2,&m_rgInfo2,&m_pStringsBuffer);
if(hr == DB_E_NOCOLUMN)
odtLog<<L"INFO: No column matched the given mask.\n";
break;
default:
TESTC(methodused==GETCOLINFO)
break;
} //switch
TESTC(CheckParams(hr, methodused))
if(GETRESCOLINFO==methodused && S_OK==hr && (m_rgInfo2!=NULL) && (m_rgColumnIDs2!=NULL))
for(DBORDINAL ulIndex=0; ulIndex<m_cColumns2; ulIndex++)
COMPARE(CompareDBID(m_rgColumnIDs2[ulIndex], m_rgInfo2[ulIndex].columnid), TRUE);
CLEANUP:
return hr;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// CheckParams
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::CheckParams(HRESULT hr, METHOD_CHOICE method)
{
TBEGIN
switch (method)
{
case GETCOLINFO:
if(S_OK==hr)
{
if(m_cColumns2)
TESTC(m_rgInfo2!=NULL && m_pStringsBuffer!=NULL)
else
{
TESTC(!m_rgInfo2 && !m_pStringsBuffer)
odtLog<<L"WARNING: No columns were returned by GetColumnInfo.\n";
}
}
else //if FAILED(hr)
{
TESTC(!m_cColumns2 && !m_rgInfo2 && !m_pStringsBuffer)
}
break;
case MAPCOLID:
break;
case GETRESCOLINFO:
if(S_OK == hr) //This is the only success code now.
{
TESTC(m_cColumns2>0 && m_pStringsBuffer!=NULL)
TESTC(m_rgColumnIDs2!=NULL || m_rgInfo2!=NULL)
}
else
TESTC(!m_cColumns2 && !m_rgColumnIDs2 && !m_rgInfo2 && !m_pStringsBuffer);
break;
default:
TESTC(m_Method==GETCOLINFO)
break;
} //switch
CLEANUP:
TRETURN
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// CheckRowSpecificColumns
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::CheckRowSpecificColumns(DBORDINAL cCols, DBCOLUMNINFO* rgInfo, DBORDINAL ulFirstOrd)
{
TBEGIN
DBORDINAL ulIndex=0;
if(cCols==0)
goto CLEANUP;
else
TESTC(cCols>0 && rgInfo!=NULL)
for(ulIndex=0; ulIndex<cCols; ulIndex++)
{
COMPARE(rgInfo[ulIndex].iOrdinal, ulFirstOrd+ulIndex);
COMPARE(rgInfo[ulIndex].columnid.eKind == DBKIND_GUID_NAME ||
rgInfo[ulIndex].columnid.eKind == DBKIND_GUID_PROPID ||
rgInfo[ulIndex].columnid.eKind == DBKIND_NAME ||
rgInfo[ulIndex].columnid.eKind == DBKIND_PROPID ||
rgInfo[ulIndex].columnid.eKind == DBKIND_GUID , TRUE);
COMPARE(rgInfo[ulIndex].dwFlags & DBCOLUMNFLAGS_ROWSPECIFICCOLUMN, DBCOLUMNFLAGS_ROWSPECIFICCOLUMN);
}
CLEANUP:
TRETURN
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// VerifyRestrictions
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::VerifyRestrictions()
{
TBEGIN
DBORDINAL iCol=0;
if(!m_cMasks && !m_rgMasks)
return TRUE;
else
TESTC(m_cMasks>0 && m_rgMasks!=NULL)
if(!m_rgInfo2 && !m_rgColumnIDs2)
{
TESTC(!m_pStringsBuffer)
odtLog<<L"INFO: No columns matched the restriction(s) provided.\n";
return TRUE;
}
else
{
TESTC(m_cColumns2>0 && m_pStringsBuffer!=NULL)
TESTC(m_rgColumnIDs2!=NULL || m_rgInfo2!=NULL)
}
for(iCol=0; iCol<m_cColumns2; iCol++)
{
BOOL bMatch = FALSE;
//if(m_rgInfo2[iCol].pwszName)
// COMPARE(wcscmp(m_rgInfo2[iCol].pwszName, m_rgInfo2[iCol].columnid.uName.pwszName), 0);
if((iCol>0) && (m_rgInfo2 != NULL))
COMPARE(m_rgInfo2[iCol].iOrdinal > m_rgInfo2[iCol-1].iOrdinal, TRUE);
for(DBORDINAL iMask=0; iMask<m_cMasks && !bMatch; iMask++)
{
WCHAR* pwszTemp = NULL;
const DBID* pColumnID = &(m_rgInfo2[iCol].columnid);
if(m_rgInfo2)
pColumnID = &(m_rgInfo2[iCol].columnid);
else
pColumnID = &(m_rgColumnIDs2[iCol]);
const DBID* pColumnMask = &m_rgMasks[iMask];
DBKIND eKind = pColumnID->eKind;
//Types ofcourse must match...
if(eKind != pColumnMask->eKind)
continue;
switch(eKind)
{
case DBKIND_GUID_NAME:
if((pColumnID->uGuid.guid == pColumnMask->uGuid.guid) &&
(pColumnID->uName.pwszName))
{
pwszTemp = wcsstr(pColumnID->uName.pwszName, pColumnMask->uName.pwszName);
if(pwszTemp && (wcscmp(pwszTemp, pColumnID->uName.pwszName)==0))
bMatch = TRUE;
}
break;
case DBKIND_GUID_PROPID:
if((pColumnID->uGuid.guid == pColumnMask->uGuid.guid) &&
(pColumnID->uName.ulPropid == pColumnMask->uName.ulPropid))
bMatch = TRUE;
break;
case DBKIND_NAME:
if(pColumnID->uName.pwszName)
{
pwszTemp = wcsstr(pColumnID->uName.pwszName, pColumnMask->uName.pwszName);
if(pwszTemp && (wcscmp(pwszTemp, pColumnID->uName.pwszName)==0))
bMatch = TRUE;
}
break;
case DBKIND_PGUID_NAME:
if((!pColumnID->uGuid.pguid && pColumnMask->uGuid.pguid) ||
(pColumnID->uGuid.pguid && !pColumnMask->uGuid.pguid) )
continue;
if(pColumnID->uGuid.pguid && pColumnMask->uGuid.pguid &&
*pColumnID->uGuid.pguid != *pColumnMask->uGuid.pguid)
continue;
if(pColumnID->uName.pwszName)
{
pwszTemp = wcsstr(pColumnID->uName.pwszName, pColumnMask->uName.pwszName);
if(pwszTemp && (wcscmp(pwszTemp, pColumnID->uName.pwszName)==0))
bMatch = TRUE;
}
break;
case DBKIND_PGUID_PROPID:
if((!pColumnID->uGuid.pguid && pColumnMask->uGuid.pguid) ||
(pColumnID->uGuid.pguid && !pColumnMask->uGuid.pguid) )
continue;
if(pColumnID->uGuid.pguid && pColumnMask->uGuid.pguid &&
*pColumnID->uGuid.pguid != *pColumnMask->uGuid.pguid)
continue;
if(pColumnID->uName.ulPropid == pColumnMask->uName.ulPropid)
bMatch = TRUE;
break;
case DBKIND_PROPID:
if(pColumnID->uName.ulPropid == pColumnMask->uName.ulPropid)
bMatch = TRUE;
break;
case DBKIND_GUID:
if(pColumnID->uGuid.guid == pColumnMask->uGuid.guid)
bMatch = TRUE;
break;
default:
//should not get here.
COMPARE(TRUE, FALSE);
break;
}//switch
}
//Make sure we found a match for every column returned.
TESTC(bMatch)
}
CLEANUP:
TRETURN
} //VerifyRestrictions
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// GetDBIDs
//
// Take DBID part of DBCOLUMNINFO and build array of DBIDs
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
HRESULT IColInfo::GetDBIDs(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns,
ULONG cExpectedRuns,
BOOL fPrep
)
{
HRESULT hr = E_FAIL;
IColumnsInfo * pIColumnsInfo = NULL;
if (!m_pICommand)
return FALSE;
if (FAILED(hr=m_pICommand->QueryInterface(IID_IColumnsInfo,
(void **)&pIColumnsInfo)))
return hr;
// Prepare the Statement
if ((m_ePreparation == SUPPORTED) && (fPrep) &&
(FAILED(hr=PrepareCommand(m_pICommand,PREPARE,cExpectedRuns))))
goto CLEANUP;
if (!m_cColumns)
if (FAILED(hr=pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer)))
goto CLEANUP;
// Make array of DBIDs
if (FAILED(hr=MakeDBIDArrays(fcColumnIDs,frgColumnIDs,frgColumns)))
goto CLEANUP;
// Prepare the Statement
if (m_ePreparation==SUPPORTED && fPrep)
hr=PrepareCommand(m_pICommand,UNPREPARE,cExpectedRuns);
CLEANUP:
SAFE_RELEASE(pIColumnsInfo);
return hr;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// MakeDBIDArrays
//
// Take DBID part of DBCOLUMNINFO and build array of DBIDs
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
HRESULT IColInfo::MakeDBIDArrays(
BOOL fcColumnIDs,
BOOL frgColumnIDs,
BOOL frgColumns
)
{
// Make array of DBIDs
if (m_cColumns)
{
if (frgColumnIDs)
{
// Allocate memory for the array of DBID's
m_rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * m_cColumns);
if (!m_rgColumnIDs) goto CLEANUP;
// Copy values into members
for(DBORDINAL ulIndex=0; ulIndex<m_cColumns; ulIndex++)
memcpy(&(m_rgColumnIDs[ulIndex]),&(m_rgInfo[ulIndex].columnid),sizeof(DBID));
}
if (frgColumns)
{
// Allocate memory for the array of DBID's
m_rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * m_cColumns);
if (!m_rgColumns) goto CLEANUP;
// Copy values into members
for(DBORDINAL ulIndex=0; ulIndex<m_cColumns; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
}
// Set count of DBID's
if (fcColumnIDs)
m_cColumnIDs = m_cColumns;
return NOERROR;
}
CLEANUP:
return E_FAIL;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// CheckOrdinal
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL IColInfo::CheckOrdinal(HRESULT hr, BOOL bCheckOrder)
{
ULONG cErrors = 0;
DBORDINAL cUnInit = 0;
// Loop thru the IDs to see if there is an invalid one
for(DBORDINAL ulIndex = 0; ulIndex < m_cColumnIDs; ulIndex++)
{
// Set to the count on E_INVALIDARG
if( !m_rgColumns )
{
cUnInit = m_cColumnIDs;
break;
}
if( m_rgColumns[ulIndex] == DB_INVALIDCOLUMN )
cErrors++;
if( m_rgColumns[ulIndex] == INVALID(DBORDINAL) )
cUnInit++;
}
if((S_OK==hr) && bCheckOrder) {
for(DBORDINAL ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
DBORDINAL ulFirst;
// Get the Oridinal
for(ulFirst=0; ulFirst<m_cColumns; ulFirst++)
{
if( CompareDBID(m_rgColumnIDs[ulIndex],
m_rgInfo[ulFirst].columnid) )
break;
}
// Compare the ordinal
if( m_rgColumns[ulIndex] )
COMPARE(m_rgColumns[ulIndex], m_rgInfo[ulFirst].iOrdinal);
}
}
// Check the ReturnCode
switch( hr )
{
case S_OK:
TESTC(!cErrors);
TESTC(!cUnInit);
break;
case DB_S_ERRORSOCCURRED:
TESTC(cErrors > 0);
TESTC(!cUnInit);
TESTC(cErrors < m_cColumnIDs);
break;
case DB_E_ERRORSOCCURRED:
TESTC(cErrors > 0);
TESTC(!cUnInit);
TESTC(cErrors == m_cColumnIDs);
break;
default:
TESTC(!cErrors);
TESTC(cUnInit > 0);
TESTC(cUnInit == m_cColumnIDs);
break;
}
return TRUE;
CLEANUP:
return FALSE;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// @mfunc General Compare routine that handles each part of the
// DBCOLUMNINFO struct and the return code
//
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void IColInfo::CheckEachColumn
(
HRESULT hr,
DBPROPID PropID,
EQUERY eSQLStmt
)
{
CCol ccol;
CTable * pLocalCTable = NULL;
DBORDINAL cLocalOrd = 0;
DB_LORDINAL* pLocalrgOrd = NULL;
DBORDINAL ulCount = 0;
// If Success with a positive column count
if (SUCCEEDED(hr) && m_cColumns)
{
// If on the Rowset change to the Rowset Object
if (m_pIRowset)
m_pIUnknown = m_pIRowset;
//TO DO - if PropID==IRowsetLocate OR BOOKMARKS, then first
//ordinal==0.
// If bookmarks are present expect a 0 ordinal
if (GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIUnknown))
if(!COMPARE(m_rgInfo[0].iOrdinal, 0))
odtLog<<L"Bookmarks are present but there is no Ordinal 0"<<ENDL;
for(DBORDINAL ulIndex=0;ulIndex<m_cColumns;ulIndex++)
{
// Check for Ordinal 0
if (m_rgInfo[ulIndex].iOrdinal==0)
{
COMPARE(Compare_DBCOLUMNFLAGS_ISBOOKMARK(m_rgInfo[ulIndex], ulIndex),TRUE);
Compare_Columnid(ccol,m_rgInfo[ulIndex],ulIndex,eSQLStmt);
}
else
{
// Change the table for joins
pLocalCTable = (CTable*)((ulCount < m_cOrdTbl1) ? m_pTable : m_pTable2);
pLocalrgOrd = ((ulCount < m_cOrdTbl1) ? m_prgOrdTbl1 : m_prgOrdTbl2);
cLocalOrd = ((ulCount < m_cOrdTbl1) ? m_cOrdTbl1 : m_cOrdTbl2);
// Check the IColumnsInfo data
if ((cLocalOrd) && (eSQLStmt != SELECT_COUNT) &&
(SUCCEEDED(pLocalCTable->GetColInfo(pLocalrgOrd[ulCount%cLocalOrd],ccol))) )
{
Compare_pwszName(ccol,m_rgInfo[ulIndex],ulIndex,eSQLStmt);
Compare_pTypeInfo(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_iOrdinal((DBORDINAL)ulIndex+(m_rgInfo[0].iOrdinal),m_rgInfo[ulIndex],ulIndex);
Compare_ulColumnSize(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_dwType(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_bPrecision(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_bScale(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_Columnid(ccol,m_rgInfo[ulIndex],ulIndex,eSQLStmt);
Compare_DBCOLUMNFLAGS_CACHEDEFERRED(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISBOOKMARK(m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISFIXEDLENGTH(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISLONG(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISNULLABLE(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISROWID(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_ISROWVER(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_MAYBENULLABLE(ccol,m_rgInfo[ulIndex],ulIndex,eSQLStmt);
Compare_DBCOLUMNFLAGS_MAYDEFER(ccol,m_rgInfo[ulIndex],ulIndex);
Compare_DBCOLUMNFLAGS_WRITE(ccol,m_rgInfo[ulIndex],ulIndex);
}
else
{
odtLog<< L"This is a Calculated column.\n";
PrintInfo(m_rgInfo, ulIndex);
}
// Incement the count
ulCount++;
}
}
}
else if (SUCCEEDED(hr) && (!m_cColumns))
{
// If cColumns is 0, the buffers are NULL
if (m_rgInfo || m_pStringsBuffer)
{
odtLog<< L"ERROR: The rgInfo pointer or pStringsBuffer was not NULL where cColumns was 0.\n";
COMPARE(1, NULL);
}
}
else
COMPARE(IfErrorParmsShouldBeNULL(), TRUE);
}
//--------------------------------------------------------------------
// @mfunc Utility function that checks that the params of
// IColumnsInfo::GetColumnInfo are correctly null if there is
// an error as the return code
//
// hr must be a failure code before coming into this function
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::IfErrorParmsShouldBeNULL()
{
// Check the pointers on ERROR
if (!m_rgInfo && !m_pStringsBuffer && !m_cColumns)
return TRUE;
odtLog<< L"ERROR: The rgInfo pointer or pStringsBuffer was not NULL on a Error.\n";
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.pwszName to the
// column name in CCol.m_pwszColName
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_pwszName(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt)
{
// Get the Column name
WCHAR wszColumnName[100] = L"";
if( col.GetColName() )
wcscpy(wszColumnName,col.GetColName());
// Check to see if the Column names have been changed
if( eSQLStmt == SELECT_CHANGECOLNAME )
wcscat(wszColumnName,L"X");
// Compare two strings, regarding upper and lower case
if( ((wszColumnName) && (dbColumnInfo.pwszName) &&
(wcscmp(wszColumnName,dbColumnInfo.pwszName) == 0)) ||
(!(*wszColumnName) && !(dbColumnInfo.pwszName)) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->NAME]: expected "
<<(*wszColumnName ? wszColumnName : L"<EMPTY>") <<L", returned "<<dbColumnInfo.pwszName <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares pTypeInfo
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_pTypeInfo(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
// Reserved
if( COMPARE(dbColumnInfo.pTypeInfo, NULL) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->ITYPEINFO]: expected NULL." <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.iOrdinal to the index.
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_iOrdinal(DBORDINAL iOrdinal, DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
// Compare the columns Ordinals
if( COMPARE(iOrdinal, dbColumnInfo.iOrdinal) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->NUMBER]: expected "
<<iOrdinal <<L", returned " <<dbColumnInfo.iOrdinal <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.wType to the
// column name in CCol.m_wProviderType
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_dwType(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
// Compare the Types
if( COMPARE(col.GetProviderType(), dbColumnInfo.wType) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->TYPE]: expected "
<<col.GetProviderType() <<L", returned " <<dbColumnInfo.wType <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.ulColumnSize to the
// column name in CCol.m_lPrecisionUsed
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_ulColumnSize(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
DBLENGTH ulHolder = ~0;
// Compare ulColumnsize as though it were count of objects
if( IsFixedLength(col.GetProviderType()) )
ulHolder=GetDBTypeSize(col.GetProviderType());
else
ulHolder=col.GetColumnSize();
// Adjust for the VARNUMERIC
if( col.GetProviderType() == DBTYPE_VARNUMERIC )
ulHolder = 20;
// Check the size
if( COMPARE(ulHolder, dbColumnInfo.ulColumnSize) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->COLUMNSIZE]: length of column expected "
<<ulHolder <<L", received " <<dbColumnInfo.ulColumnSize <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.bPrecision to the
// column name in CCol.m_lPrecision
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_bPrecision(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BYTE bNumericPrec = ~0;
// Get the Precision of the Column
if( col.GetProviderType() != DBTYPE_DBTIMESTAMP )
bNumericPrec=bNumericPrecision(col.GetProviderType(), col);
else
bNumericPrec=col.GetPrecision();
if( COMPARE(dbColumnInfo.bPrecision, bNumericPrec) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->PRECISION]: precision of column expected " <<bNumericPrec
<<L", received " <<dbColumnInfo.bPrecision <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.bScale to the
// scale in CCol.m_sScale
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_bScale(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BYTE bNumericScale = ~0;
// Get the Precision of the Column
if( IsScaleType(col.GetProviderType()) )
bNumericScale=col.GetScale();
if( COMPARE(bNumericScale, dbColumnInfo.bScale) )
return TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->SCALE]: expects "
<<col.GetScale() <<L", returned "
<<dbColumnInfo.bScale <<ENDL;
return FALSE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.columnid to the
// column name in CCol.
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_Columnid(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt)
{
BOOL fSuccess = FALSE;
WCHAR wszColumnName[100] = L"";
DBORDINAL ulOrdinal = 0;
ULONG_PTR ulIDType = 0;
DBID * rgColumnIDs = NULL;
// Get the property value
GetProperty(DBPROP_PERSISTENTIDTYPE, DBPROPSET_DATASOURCEINFO, m_pMyIDBInitialize, &ulIDType);
// Get the Column name
if (col.GetColName())
wcscpy(wszColumnName,col.GetColName());
// This should cover DBKIND_GUID_NAME
if ((dbColumnInfo.columnid).eKind == DBKIND_GUID_NAME)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_GUID_NAME for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_GUID_NAME);
// Check to see if the Column names have been changed
if (eSQLStmt == SELECT_CHANGECOLNAME)
wcscat(wszColumnName,L"X");
// Compare two strings, regarding upper and lower case
if (((wszColumnName) && ((dbColumnInfo.columnid).uName.pwszName) &&
(wcscmp(wszColumnName,(dbColumnInfo.columnid).uName.pwszName) == 0)) ||
(!(*wszColumnName) && !((dbColumnInfo.columnid).uName.pwszName)))
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<(*wszColumnName ? wszColumnName : L"<EMPTY>") <<L", returned "<<(dbColumnInfo.columnid).uName.pwszName <<ENDL;
return FALSE;
}
}
// This should cover DBKIND_GUID_PROPID
else if ((dbColumnInfo.columnid).eKind == DBKIND_GUID_PROPID)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_GUID_PROPID for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else if (m_rgInfo[ulIndex].iOrdinal)
COMPARE(ulIDType, DBPROPVAL_PT_GUID_PROPID);
// If Bookmark column
if (!m_rgInfo[ulIndex].iOrdinal)
{
// Compare two iOrdinal and ulPropid
if ((2 == (dbColumnInfo.columnid).uName.ulPropid) &&
((dbColumnInfo.columnid).uGuid.guid == DBCOL_SPECIALCOL))
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<m_rgInfo[ulIndex].iOrdinal <<L", returned "<<(dbColumnInfo.columnid).uName.ulPropid <<ENDL;
return FALSE;
}
}
else
{
// Get the Ordinal back from MapColumnIDs
rgColumnIDs = &dbColumnInfo.columnid;
if(m_pIColumnsInfo)
CHECK(m_pIColumnsInfo->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
else if(m_pIColumnsInfo2)
CHECK(m_pIColumnsInfo2->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
rgColumnIDs=NULL;
// Compare two iOrdinal and ulPropid
if (ulOrdinal == m_rgInfo[ulIndex].iOrdinal)
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<m_rgInfo[ulIndex].iOrdinal <<L", returned "<<(dbColumnInfo.columnid).uName.ulPropid <<ENDL;
return FALSE;
}
}
}
// This should cover DBKIND_NAME
else if ((dbColumnInfo.columnid).eKind == DBKIND_NAME)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_NAME for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_NAME);
// Check to see if the Column names have been changed
if (eSQLStmt == SELECT_CHANGECOLNAME)
wcscat(wszColumnName,L"X");
// Compare two strings, regarding upper and lower case
if (((wszColumnName) && ((dbColumnInfo.columnid).uName.pwszName) &&
(wcscmp(wszColumnName,(dbColumnInfo.columnid).uName.pwszName) == 0)) ||
(!(*wszColumnName) && !((dbColumnInfo.columnid).uName.pwszName)))
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<(*wszColumnName ? wszColumnName : L"<EMPTY>") <<L", returned "<<(dbColumnInfo.columnid).uName.pwszName <<ENDL;
return FALSE;
}
}
// This should cover DBKIND_PGUID_NAME
else if ((dbColumnInfo.columnid).eKind == DBKIND_PGUID_NAME)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_PGUID_NAME for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_PGUID_NAME);
// Check to see if the Column names have been changed
if (eSQLStmt == SELECT_CHANGECOLNAME)
wcscat(wszColumnName,L"X");
// Compare two strings, regarding upper and lower case
if (((wszColumnName) && ((dbColumnInfo.columnid).uName.pwszName) &&
(wcscmp(wszColumnName,(dbColumnInfo.columnid).uName.pwszName) == 0)) ||
(!(*wszColumnName) && !((dbColumnInfo.columnid).uName.pwszName)))
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<(*wszColumnName ? wszColumnName : L"<EMPTY>") <<L", returned "<<(dbColumnInfo.columnid).uName.pwszName <<ENDL;
return FALSE;
}
}
// This should cover DBKIND_PGUID_PROPID
else if ((dbColumnInfo.columnid).eKind == DBKIND_PGUID_PROPID)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_PGUID_PROPID for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_PGUID_PROPID);
// Get the Ordinal back from MapColumnIDs
rgColumnIDs = &dbColumnInfo.columnid;
if(m_pIColumnsInfo)
CHECK(m_pIColumnsInfo->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
else if(m_pIColumnsInfo2)
CHECK(m_pIColumnsInfo2->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
rgColumnIDs=NULL;
// Compare two iOrdinal and ulPropid
if (ulOrdinal == m_rgInfo[ulIndex].iOrdinal)
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<m_rgInfo[ulIndex].iOrdinal <<L", returned "<<(dbColumnInfo.columnid).uName.ulPropid <<ENDL;
return FALSE;
}
}
// This should cover DBKIND_PROPID
else if ((dbColumnInfo.columnid).eKind == DBKIND_PROPID)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_PROPID for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_PROPID);
// Get the Ordinal back from MapColumnIDs
rgColumnIDs = &dbColumnInfo.columnid;
if(m_pIColumnsInfo)
CHECK(m_pIColumnsInfo->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
else if(m_pIColumnsInfo2)
CHECK(m_pIColumnsInfo2->MapColumnIDs(1,rgColumnIDs,&ulOrdinal), S_OK);
rgColumnIDs=NULL;
// Compare two iOrdinal and ulPropid
if (ulOrdinal == m_rgInfo[ulIndex].iOrdinal)
return TRUE;
else
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: expected "
<<m_rgInfo[ulIndex].iOrdinal <<L", returned "<<(dbColumnInfo.columnid).uName.ulPropid <<ENDL;
return FALSE;
}
}
// This should cover DBKIND_GUID
else if ((dbColumnInfo.columnid).eKind == DBKIND_GUID)
{
// Check the property value being returned
if (!ulIDType)
odtLog << L"Should return DBPROPVAL_PT_GUID for DBPROP_PERSISTENTIDTYPE" <<ENDL;
else
COMPARE(ulIDType, DBPROPVAL_PT_GUID);
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->DBKIND_GUID]: Not tested. " <<ENDL;
}
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType <<L" ->COLUMNID]: IS BAD " <<ENDL;
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_CACHEDEFERRED
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_CACHEDEFERRED(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check the DBPROP_CACHEDEFERRED Property
if (GetProperty(DBPROP_CACHEDEFERRED, DBPROPSET_ROWSET, m_pIUnknown))
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_CACHEDEFERRED)
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->CACHEDEFERRED]: expected, but isn't present."<<ENDL;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_CACHEDEFERRED)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->CACHEDEFERRED]: was not expected, but was present."<<ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISBOOKMARK to
// to the iOrdinal of zero.
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISBOOKMARK(DBCOLUMNINFO dbColumnInfo, DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check the Ordinal of the column
if (dbColumnInfo.iOrdinal == 0)
{
// Check for the Bookmark Property and then the FLAG
if ((!GetProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET, m_pIUnknown)) &&
(!GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIUnknown)) )
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<"Bookmark" <<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISBOOKMARK]: expected bookmark property to be set, but isn't set."<< ENDL;
else if (!(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISBOOKMARK))
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<"Bookmark" <<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISBOOKMARK]: expected bookmark, but isn't present."<< ENDL;
else
fSuccess = TRUE;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISBOOKMARK)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISBOOKMARK]: didn't expect the bookmark, but it is present."<< ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISFIXEDLENGTH
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISFIXEDLENGTH(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check to see if the type is FixedLength
if ((IsFixedLength(col.GetProviderType())) || (col.GetIsFixedLength()))
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISFIXEDLENGTH)
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->FIXEDLENGTH]: type is fixedlen but flag not set."<<ENDL;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISFIXEDLENGTH)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->FIXEDLENGTH]: type is not fixedlen but flag was set."<<ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISLONG
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISLONG(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check to see if the column is Long
if (col.GetIsLong())
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISLONG)
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISLONG]: type is Long but flag not set."<<ENDL;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISLONG)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISLONG]: type is not Long but flag was set."<< ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISNULLABLE
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISNULLABLE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// See if the Column is NULLABLE
if (col.GetNullable())
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISNULLABLE)
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISNULLABLE]: expected, but isn't present."<<ENDL;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISNULLABLE)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISNULLABLE]: is not expected, but is present."<<ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISROWID
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISROWID(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISROWID)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISROWID]: returned for this column."<<ENDL;
return TRUE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_ISROWVER
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_ISROWVER(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISROWVER)
{
// Check to see if the column is nullable or updatable
if( (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_ISNULLABLE) || (col.GetNullable()) ||
(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITE) || (col.GetUpdateable()) )
{
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->ISROWVER]: returned for this column and the column is NULLABLE or WRITEABLE."<<ENDL;
return FALSE;
}
}
return TRUE;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_MAYBENULL
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_MAYBENULLABLE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex,EQUERY eSQLStmt)
{
BOOL fSuccess = FALSE;
// See if the Column is MAYBENULL (JOINS
if (((col.GetNullable()) && (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_MAYBENULL)) ||
(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_MAYBENULL))
fSuccess = TRUE;
else
{
if((eSQLStmt != SELECT_LEFTOUTERJOIN) && (eSQLStmt != SELECT_RIGHTOUTERJOIN))
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->MAYBENULL]: expected, but isn't present."<<ENDL;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_MAYDEFER
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_MAYDEFER(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check the DBPROP_DEFERRED Property
if (GetProperty(DBPROP_DEFERRED, DBPROPSET_ROWSET, m_pIUnknown))
{
if ((dbColumnInfo.dwFlags & DBCOLUMNFLAGS_MAYDEFER) ||
(!(col.GetIsLong())) )
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->MAYDEFER]: expected, but isn't present."<<ENDL;
}
else
{
if (dbColumnInfo.dwFlags & DBCOLUMNFLAGS_MAYDEFER)
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->MAYDEFER]: was not expected, but was present."<<ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @mfunc Utility function that compares DBCOLUMNINFO.DBCOLUMNFLAGS_WRITE
//
//
// @rdesc TRUE or FALSE
//
BOOL IColInfo::Compare_DBCOLUMNFLAGS_WRITE(CCol col,DBCOLUMNINFO dbColumnInfo,DBORDINAL ulIndex)
{
BOOL fSuccess = FALSE;
// Check to see if the column is readonly
if (col.GetUpdateable())
{
if (((dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITE) &&
(!(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITEUNKNOWN))) ||
((dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITEUNKNOWN) &&
(!(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITE))))
fSuccess = TRUE;
else
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->WRITE & WRITEUNKNOWN]: not expected, but both are present."<<ENDL;
}
else
{
if ((dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITE) ||
(dbColumnInfo.dwFlags & DBCOLUMNFLAGS_WRITEUNKNOWN))
odtLog<<L"[ " <<m_rgInfo[ulIndex].iOrdinal <<L" - "
<<(m_rgInfo[ulIndex].pwszName ? m_rgInfo[ulIndex].pwszName : L"<EMPTY>")
<<L" - " <<m_rgInfo[ulIndex].wType
<<L" ->WRITE or WRITEUNKNOWN]: is not expected, but is present."<<ENDL;
else
fSuccess = TRUE;
}
return fSuccess;
}
//--------------------------------------------------------------------
// @class zombie on CTransaction
//
class Zombie : public CTransaction
{
public:
Zombie(const LPWSTR wszTestCaseName): CTransaction(wszTestCaseName){};
int TestTxnCmd(ETXN eTxn, BOOL fRetaining);
int TestTxnRowset(ETXN eTxn, BOOL fRetaining,BOOL fMultRowsets=FALSE);
int TestTxnRow(ETXN eTxn, BOOL fRetaining);
};
//*-----------------------------------------------------------------------
// @mfunc TestTxn
// Tests commit/abort with respect to IAccessor on commands
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Zombie::TestTxnCmd(ETXN eTxn,BOOL fRetaining)
{
BOOL fSuccess = FALSE;
HRESULT ExpectedHr = E_UNEXPECTED;
HRESULT ExpColInfoHr = DB_E_NOTPREPARED;
DBORDINAL index = 0;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBORDINAL cColumnIDs = 0;
DBID * rgColumnIDs = NULL;
DBORDINAL * rgColumns = NULL;
DBORDINAL cColumns = 0;
DBCOLUMNINFO * rgInfo = NULL;
WCHAR * pStringsBuffer = NULL;
IColumnsInfo * pIColumnsInfo = NULL;
if (!StartTransaction(SELECT_ALLFROMTBL, (IUnknown **)&pIColumnsInfo,
0, NULL, NULL, ISOLATIONLEVEL_READUNCOMMITTED, TRUE))
goto CLEANUP;
//Make sure everything still works after commit or abort
CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer),S_OK);
// build array of DBIDs
if(cColumns)
{
cColumnIDs = cColumns;
rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * cColumns);
rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * cColumns);
for(index=0;index<cColumns;index++)
DuplicateDBID(rgInfo[index].columnid, &rgColumnIDs[index]);
}
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
if (eTxn == ETXN_COMMIT)
{
// Commit the transaction, with retention as specified
if (!GetCommit(fRetaining))
goto CLEANUP;
}
else
{
// Abort the transaction, with retention as specified
if (!GetAbort(fRetaining))
goto CLEANUP;
}
// Make sure everything still works after commit or abort
if ((eTxn == ETXN_COMMIT && m_fCommitPreserve) ||
(eTxn == ETXN_ABORT && m_fAbortPreserve))
ExpectedHr = S_OK;
// Test zombie
CHECK(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
// Make sure everything still works after commit or abort
if ((eTxn == ETXN_COMMIT && m_fPrepareCommitPreserve) ||
(eTxn == ETXN_ABORT && m_fPrepareAbortPreserve))
ExpColInfoHr = S_OK;
// Transaction object prepares so I have to check for S_OK
// Make sure everything still works after commit or abort
CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer), ExpColInfoHr);
{
// Transaction object doesn't prepare so I have to check for S_OK
fSuccess = CHECK(pIColumnsInfo->MapColumnIDs(cColumnIDs,rgColumnIDs,rgColumns),ExpColInfoHr);
}
CLEANUP:
// Release the objects and cleanup memory
SAFE_RELEASE(pIColumnsInfo);
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
// Free the memory allocated for MapColIDs
for(index=0;index<cColumnIDs;index++)
ReleaseDBID(&rgColumnIDs[index],FALSE);
PROVIDER_FREE(rgColumnIDs);
PROVIDER_FREE(rgColumns);
// Release the row handle on the 1st rowset
if (rghRows)
{
CHECK(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL),S_OK);
PROVIDER_FREE(rghRows);
}
//Return code of Commit/Abort will vary depending on whether
//or not we have an open txn, so adjust accordingly
if (fRetaining)
ExpectedHr = S_OK;
else
ExpectedHr = XACT_E_NOTRANSACTION;
CleanUpTransaction(ExpectedHr);
if (fSuccess)
return TEST_PASS;
else
return TEST_FAIL;
}
//*-----------------------------------------------------------------------
// @mfunc TestTxn
// Tests commit/abort with respect to IAccessor on commands
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Zombie::TestTxnRowset(ETXN eTxn,BOOL fRetaining,BOOL fMultRowsets)
{
BOOL fSuccess = FALSE;
HRESULT ExpectedHr = E_UNEXPECTED;
DBORDINAL index = 0;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBORDINAL cColumnIDs = 0;
DBID * rgColumnIDs = NULL;
DBORDINAL * rgColumns = NULL;
DBORDINAL cColumns = 0;
DBCOLUMNINFO * rgInfo = NULL;
WCHAR * pStringsBuffer = NULL;
IColumnsInfo * pIColumnsInfo = NULL;
ULONG cPropSets = 0;
DBPROPSET * rgPropSets = NULL;
IColumnsInfo * pIRowset1 = NULL;
DBORDINAL cColumns1 = 0;
DBCOLUMNINFO * rgColumns1 = NULL;
OLECHAR* pStringsBuffer1 = NULL;
IColumnsInfo * pIRowset2 = NULL;
DBORDINAL cColumns2 = 0;
DBCOLUMNINFO * rgColumns2 = NULL;
OLECHAR* pStringsBuffer2 = NULL;
IColumnsInfo * pIRowset3 = NULL;
DBORDINAL cColumns3 = 0;
DBCOLUMNINFO * rgColumns3 = NULL;
OLECHAR* pStringsBuffer3 = NULL;
if( (SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBCreateSession)) &&
(SettableProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBCreateSession)) )
SetProperty(DBPROP_BOOKMARKS,DBPROPSET_ROWSET,
&cPropSets,&rgPropSets,DBTYPE_BOOL,VARIANT_TRUE,DBPROPOPTIONS_REQUIRED);
if (!StartTransaction(SELECT_ALLFROMTBL, (IUnknown **)&pIColumnsInfo,
cPropSets, rgPropSets, NULL, ISOLATIONLEVEL_READUNCOMMITTED, TRUE))
goto CLEANUP;
if (fMultRowsets)
{
if (m_pICommand)
{
CHECK(m_pICommand->Execute(NULL,IID_IColumnsInfo,NULL,NULL,(IUnknown**)&pIRowset1),S_OK);
CHECK(m_pICommand->Execute(NULL,IID_IColumnsInfo,NULL,NULL,(IUnknown**)&pIRowset2),S_OK);
CHECK(m_pICommand->Execute(NULL,IID_IColumnsInfo,NULL,NULL,(IUnknown**)&pIRowset3),S_OK);
}
}
//Make sure everything still works after commit or abort
CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer),S_OK);
// build array of DBIDs
if(cColumns)
{
cColumnIDs = cColumns;
rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * cColumns);
rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * cColumns);
for(index=0;index<cColumns;index++)
DuplicateDBID(rgInfo[index].columnid, &rgColumnIDs[index]);
}
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
if (eTxn == ETXN_COMMIT)
{
//Commit the transaction, with retention as specified
if(!GetCommit(fRetaining))
goto CLEANUP;
}
else
{
//Abort the transaction, with retention as specified
if(!GetAbort(fRetaining))
goto CLEANUP;
}
// Make sure everything still works after commit or abort
if ((eTxn == ETXN_COMMIT && m_fCommitPreserve) ||
(eTxn == ETXN_ABORT && m_fAbortPreserve))
ExpectedHr = S_OK;
// Test zombie
CHECK(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
//Make sure everything still works after commit or abort
if (CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer),ExpectedHr))
{
fSuccess = CHECK(pIColumnsInfo->MapColumnIDs(cColumnIDs,rgColumnIDs,rgColumns),ExpectedHr);
// make sure rowset1-3 are still alive
if (pIRowset1)
CHECK(pIRowset1->GetColumnInfo(&cColumns1,&rgColumns1,&pStringsBuffer1),ExpectedHr);
if (pIRowset2)
CHECK(pIRowset2->GetColumnInfo(&cColumns2,&rgColumns2,&pStringsBuffer2),ExpectedHr);
if (pIRowset3)
CHECK(pIRowset3->GetColumnInfo(&cColumns3,&rgColumns3,&pStringsBuffer3),ExpectedHr);
}
CLEANUP:
// Release the row handle on the 1st rowset
if (rghRows)
{
CHECK(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL),S_OK);
PROVIDER_FREE(rghRows);
}
// Release the objects and cleanup memory
SAFE_RELEASE(pIColumnsInfo);
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
PROVIDER_FREE(pStringsBuffer1);
PROVIDER_FREE(pStringsBuffer2);
PROVIDER_FREE(pStringsBuffer3);
// Free the memory allocated for MapColIDs
for(index=0;index<cColumnIDs;index++)
ReleaseDBID(&rgColumnIDs[index],FALSE);
PROVIDER_FREE(rgColumnIDs);
PROVIDER_FREE(rgColumns);
PROVIDER_FREE(rgColumns1);
PROVIDER_FREE(rgColumns2);
PROVIDER_FREE(rgColumns3);
PROVIDER_FREE(rghRows);
SAFE_RELEASE(pIRowset1);
SAFE_RELEASE(pIRowset2);
SAFE_RELEASE(pIRowset3);
FreeProperties(&cPropSets, &rgPropSets);
//Return code of Commit/Abort will vary depending on whether
//or not we have an open txn, so adjust accordingly
if (fRetaining)
ExpectedHr = S_OK;
else
ExpectedHr = XACT_E_NOTRANSACTION;
CleanUpTransaction(ExpectedHr);
if (fSuccess)
return TEST_PASS;
else
return TEST_FAIL;
}
//*-----------------------------------------------------------------------
// @mfunc TestTxn
// Tests commit/abort with respect to IAccessor on commands
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Zombie::TestTxnRow(ETXN eTxn,BOOL fRetaining)
{
BOOL fSuccess = FALSE;
HRESULT ExpectedHr = E_UNEXPECTED;
DBORDINAL index = 0;
DBCOUNTITEM cRowsObtained = 0;
HROW * rghRows = NULL;
DBORDINAL cColumnIDs = 0;
DBID * rgColumnIDs = NULL;
DBORDINAL * rgColumns = NULL;
DBORDINAL cColumns = 0;
DBCOLUMNINFO * rgInfo = NULL;
WCHAR * pStringsBuffer = NULL;
IColumnsInfo * pIColumnsInfo = NULL;
ULONG cPropSets = 0;
DBPROPSET * rgPropSets = NULL;
if( (SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBCreateSession)) &&
(SettableProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBCreateSession)) )
SetProperty(DBPROP_BOOKMARKS,DBPROPSET_ROWSET,
&cPropSets,&rgPropSets,DBTYPE_BOOL,VARIANT_TRUE,DBPROPOPTIONS_REQUIRED);
if (!StartTransaction(SELECT_ALLFROMTBL, (IUnknown **)&pIColumnsInfo,
cPropSets, rgPropSets, NULL, ISOLATIONLEVEL_READUNCOMMITTED, TRUE))
goto CLEANUP;
//Make sure everything still works after commit or abort
CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer),S_OK);
// build array of DBIDs
if(cColumns)
{
cColumnIDs = cColumns;
rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * cColumns);
rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * cColumns);
for(index=0;index<cColumns;index++)
DuplicateDBID(rgInfo[index].columnid, &rgColumnIDs[index]);
}
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
if (eTxn == ETXN_COMMIT)
{
//Commit the transaction, with retention as specified
if(!GetCommit(fRetaining))
goto CLEANUP;
}
else
{
//Abort the transaction, with retention as specified
if(!GetAbort(fRetaining))
goto CLEANUP;
}
// Make sure everything still works after commit or abort
if ((eTxn == ETXN_COMMIT && m_fCommitPreserve) ||
(eTxn == ETXN_ABORT && m_fAbortPreserve))
ExpectedHr = S_OK;
// Test zombie
CHECK(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
//Make sure everything still works after commit or abort
// Per spec, E_UNEXPECTED will only be returned for Rowsets.
if (CHECK(pIColumnsInfo->GetColumnInfo(&cColumns,&rgInfo,&pStringsBuffer),S_OK))
{
fSuccess = CHECK(pIColumnsInfo->MapColumnIDs(cColumnIDs,rgColumnIDs,rgColumns),S_OK);
}
CLEANUP:
// Release the row handle on the 1st rowset
if (rghRows)
{
CHECK(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL),S_OK);
PROVIDER_FREE(rghRows);
}
// Release the objects and cleanup memory
SAFE_RELEASE(pIColumnsInfo);
PROVIDER_FREE(rgInfo);
PROVIDER_FREE(pStringsBuffer);
// Free the memory allocated for MapColIDs
for(index=0;index<cColumnIDs;index++)
ReleaseDBID(&rgColumnIDs[index],FALSE);
PROVIDER_FREE(rgColumnIDs);
PROVIDER_FREE(rgColumns);
PROVIDER_FREE(rghRows);
FreeProperties(&cPropSets, &rgPropSets);
//Return code of Commit/Abort will vary depending on whether
//or not we have an open txn, so adjust accordingly
if (fRetaining)
ExpectedHr = S_OK;
else
ExpectedHr = XACT_E_NOTRANSACTION;
CleanUpTransaction(ExpectedHr);
if (fSuccess)
return TEST_PASS;
else
return TEST_FAIL;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_TEST_CASE_MAP(GetColInfo_Command)
//--------------------------------------------------------------------
// @class IColumnsInfo on a command object
//
class GetColInfo_Command : public IColInfo {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetColInfo_Command,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumns is NULL
int Variation_1();
// @cmember E_INVALIDARG: rgInfo is NULL
int Variation_2();
// @cmember E_INVALIDARG: pStringsBuffer is NULL
int Variation_3();
// @cmember DB_E_NOCOMMAND: CommandText is not Set
int Variation_4();
// @cmember DB_E_NOCOMMAND: CommandText is Set to Empty
int Variation_5();
// @cmember DB_E_NOCOMMAND: CommandText is Set to NULL
int Variation_6();
// @cmember DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared
int Variation_7();
// @cmember DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared
int Variation_8();
// @cmember S_OK: CommandText is Set and Prepared
int Variation_9();
// @cmember S_OK: CommandText includes duplicate columns
int Variation_10();
// @cmember S_OK: CommandText is Set, then change the Text
int Variation_11();
// @cmember S_OK: CommandText contains a count(*)
int Variation_12();
// @cmember S_OK: CommandText contains different column names
int Variation_13();
// @cmember S_OK: CommandText contains a insert statement
int Variation_14();
// @cmember S_OK: CommandText contains a select from an Empty Rowset
int Variation_15();
// @cmember S_OK: Base table contains no rows
int Variation_16();
// @cmember S_OK: CommandText contains a update statement
int Variation_17();
// @cmember S_OK: CommandText contains a delete statement
int Variation_18();
// @cmember S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
int Variation_19();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
int Variation_20();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS on a Insert Statement
int Variation_21();
// @cmember S_OK: Ask for DBPROP_DEFERRED on a Select Statement
int Variation_22();
// @cmember S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
int Variation_23();
// @cmember S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
int Variation_24();
// @cmember S_OK: CommandText contains a select from view
int Variation_25();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement with Column List
int Variation_26();
// @cmember S_OK: CommandText contains a LEFT OUTER JOIN
int Variation_27();
// @cmember S_OK: CommandText contains a RIGHT OUTER JOIN
int Variation_28();
// @cmember DB_E_NOTABLE: Call with a Table that doesn't exist
int Variation_29();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetColInfo_Command)
#define THE_CLASS GetColInfo_Command
BEG_TEST_CASE(GetColInfo_Command, IColInfo, L"IColumnsInfo on a command object")
TEST_VARIATION(1, L"E_INVALIDARG: cColumns is NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgInfo is NULL")
TEST_VARIATION(3, L"E_INVALIDARG: pStringsBuffer is NULL")
TEST_VARIATION(4, L"DB_E_NOCOMMAND: CommandText is not Set")
TEST_VARIATION(5, L"DB_E_NOCOMMAND: CommandText is Set to Empty")
TEST_VARIATION(6, L"DB_E_NOCOMMAND: CommandText is Set to NULL")
TEST_VARIATION(7, L"DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared")
TEST_VARIATION(8, L"DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared")
TEST_VARIATION(9, L"S_OK: CommandText is Set and Prepared")
TEST_VARIATION(10, L"S_OK: CommandText includes duplicate columns")
TEST_VARIATION(11, L"S_OK: CommandText is Set, then change the Text")
TEST_VARIATION(12, L"S_OK: CommandText contains a count(*)")
TEST_VARIATION(13, L"S_OK: CommandText contains different column names")
TEST_VARIATION(14, L"S_OK: CommandText contains a insert statement")
TEST_VARIATION(15, L"S_OK: CommandText contains a select from an Empty Rowset")
TEST_VARIATION(16, L"S_OK: Base table contains no rows")
TEST_VARIATION(17, L"S_OK: CommandText contains a update statement")
TEST_VARIATION(18, L"S_OK: CommandText contains a delete statement")
TEST_VARIATION(19, L"S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement")
TEST_VARIATION(20, L"S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement")
TEST_VARIATION(21, L"S_OK: Ask for DBPROP_BOOKMARKS on a Insert Statement")
TEST_VARIATION(22, L"S_OK: Ask for DBPROP_DEFERRED on a Select Statement")
TEST_VARIATION(23, L"S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement")
TEST_VARIATION(24, L"S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement")
TEST_VARIATION(25, L"S_OK: CommandText contains a select from view")
TEST_VARIATION(26, L"S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement with Column List")
TEST_VARIATION(27, L"S_OK: CommandText contains a LEFT OUTER JOIN")
TEST_VARIATION(28, L"S_OK: CommandText contains a RIGHT OUTER JOIN")
TEST_VARIATION(29, L"DB_E_NOTABLE: Call with a Table that doesn't exist")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetColInfo_ExecuteRowset)
//--------------------------------------------------------------------
// @class IColumnsInfo on a rowset object
//
class GetColInfo_ExecuteRowset : public IColInfo {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetColInfo_ExecuteRowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumns is NULL
int Variation_1();
// @cmember E_INVALIDARG: rgInfo is NULL
int Variation_2();
// @cmember E_INVALIDARG: pStringsBuffer is NULL
int Variation_3();
// @cmember S_OK: CommandText is Set and Executed
int Variation_4();
// @cmember S_OK: CommandText is Set, Prepared, Unprepared, and Executed
int Variation_5();
// @cmember S_OK: CommandText is Set, Prepared, and Executed
int Variation_6();
// @cmember S_OK: CommandText that includes duplicate columns
int Variation_7();
// @cmember S_OK: CommandText is Set, then change the Text
int Variation_8();
// @cmember S_OK: CommandText contains a count(*)
int Variation_9();
// @cmember S_OK: CommandText contains different column names
int Variation_10();
// @cmember S_OK: CommandText contains a select from an Empty Rowset
int Variation_11();
// @cmember S_OK: Base table contains no rows
int Variation_12();
// @cmember S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
int Variation_13();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
int Variation_14();
// @cmember S_OK: Ask for DBPROP_DEFERRED on a Select Statement
int Variation_15();
// @cmember S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
int Variation_16();
// @cmember S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
int Variation_17();
// @cmember S_OK: CommandText contains a select from view
int Variation_18();
// @cmember S_OK: CommandText contains a LEFT OUTER JOIN
int Variation_19();
// @cmember S_OK: CommandText contains a RIGHT OUTER JOIN
int Variation_20();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetColInfo_ExecuteRowset)
#define THE_CLASS GetColInfo_ExecuteRowset
BEG_TEST_CASE(GetColInfo_ExecuteRowset, IColInfo, L"IColumnsInfo on a rowset object")
TEST_VARIATION(1, L"E_INVALIDARG: cColumns is NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgInfo is NULL")
TEST_VARIATION(3, L"E_INVALIDARG: pStringsBuffer is NULL")
TEST_VARIATION(4, L"S_OK: CommandText is Set and Executed")
TEST_VARIATION(5, L"S_OK: CommandText is Set, Prepared, Unprepared, and Executed")
TEST_VARIATION(6, L"S_OK: CommandText is Set, Prepared, and Executed")
TEST_VARIATION(7, L"S_OK: CommandText that includes duplicate columns")
TEST_VARIATION(8, L"S_OK: CommandText is Set, then change the Text")
TEST_VARIATION(9, L"S_OK: CommandText contains a count(*)")
TEST_VARIATION(10, L"S_OK: CommandText contains different column names")
TEST_VARIATION(11, L"S_OK: CommandText contains a select from an Empty Rowset")
TEST_VARIATION(12, L"S_OK: Base table contains no rows")
TEST_VARIATION(13, L"S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement")
TEST_VARIATION(14, L"S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement")
TEST_VARIATION(15, L"S_OK: Ask for DBPROP_DEFERRED on a Select Statement")
TEST_VARIATION(16, L"S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement")
TEST_VARIATION(17, L"S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement")
TEST_VARIATION(18, L"S_OK: CommandText contains a select from view")
TEST_VARIATION(19, L"S_OK: CommandText contains a LEFT OUTER JOIN")
TEST_VARIATION(20, L"S_OK: CommandText contains a RIGHT OUTER JOIN")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetColInfo_OpenRowset)
//--------------------------------------------------------------------
// @class IColumnsInfo on a rowset object
//
class GetColInfo_OpenRowset : public IColInfo {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetColInfo_OpenRowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumns is NULL
int Variation_1();
// @cmember E_INVALIDARG: rgInfo is NULL
int Variation_2();
// @cmember E_INVALIDARG: pStringsBuffer is NULL
int Variation_3();
// @cmember S_OK: Basic OpenRowset
int Variation_4();
// @cmember S_OK: Base table contains no rows
int Variation_5();
// @cmember S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
int Variation_6();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
int Variation_7();
// @cmember S_OK: Ask for DBPROP_DEFERRED on a Select Statement
int Variation_8();
// @cmember S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
int Variation_9();
// @cmember S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
int Variation_10();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(GetColInfo_OpenRowset)
#define THE_CLASS GetColInfo_OpenRowset
BEG_TEST_CASE(GetColInfo_OpenRowset, IColInfo, L"IColumnsInfo on a rowset object")
TEST_VARIATION(1, L"E_INVALIDARG: cColumns is NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgInfo is NULL")
TEST_VARIATION(3, L"E_INVALIDARG: pStringsBuffer is NULL")
TEST_VARIATION(4, L"S_OK: Basic OpenRowset")
TEST_VARIATION(5, L"S_OK: Base table contains no rows")
TEST_VARIATION(6, L"S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement")
TEST_VARIATION(7, L"S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement")
TEST_VARIATION(8, L"S_OK: Ask for DBPROP_DEFERRED on a Select Statement")
TEST_VARIATION(9, L"S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement")
TEST_VARIATION(10, L"S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetColInfoRow_Rowset)
//*-----------------------------------------------------------------------
// @class GetColumnInfo on a Row object
//
class GetColInfoRow_Rowset : public IColInfo {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetColInfoRow_Rowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember S_OK: Basic
int Variation_1();
// @cmember E_INVALIDARG: pcColumns is NULL
int Variation_2();
// @cmember E_INVALIDARG: prgInfo is NULL
int Variation_3();
// @cmember E_INVALIDARG: ppStringsBuffer is NULL
int Variation_4();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(GetColInfoRow_Rowset)
#define THE_CLASS GetColInfoRow_Rowset
BEG_TEST_CASE(GetColInfoRow_Rowset, IColInfo, L"GetColumnInfo on a Row object")
TEST_VARIATION(1, L"S_OK: Basic")
TEST_VARIATION(2, L"E_INVALIDARG: pcColumns is NULL")
TEST_VARIATION(3, L"E_INVALIDARG: prgInfo is NULL")
TEST_VARIATION(4, L"E_INVALIDARG: ppStringsBuffer is NULL")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(GetResColInfoRow_Rowset)
//*-----------------------------------------------------------------------
// @class GetRestrictedColumnInfo on a Row object
//
class GetResColInfoRow_Rowset : public IColInfo {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(GetResColInfoRow_Rowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember S_OK: No Masks
int Variation_1();
// @cmember S_OK: 1 name mask
int Variation_2();
// @cmember S_OK: Multiple name masks
int Variation_3();
// @cmember S_OK: Existing Column as mask
int Variation_4();
// @cmember S_OK: GUID_PROPID mask
int Variation_5();
// @cmember S_OK: Guid_Name mask
int Variation_6();
// @cmember S_OK: Pguid_Name mask
int Variation_7();
// @cmember S_OK: PGuid_Propid mask
int Variation_8();
// @cmember S_OK: Propid mask
int Variation_9();
// @cmember S_OK: Guid mask
int Variation_10();
// @cmember S_OK: prgColumnIDs=NULL but prgColumnInfo != NULL
int Variation_11();
// @cmember S_OK: prgColumnInfo=NULL but prgColumnIDs != NULL
int Variation_12();
// @cmember DB_E_BADCOLUMNID: invalid DBID for rgColumnIDMasks
int Variation_13();
// @cmember DB_E_NOCOLUMN: Non-existent name for mask
int Variation_14();
// @cmember E_INVALIDARG: cColumnIDMasks=1 and rgColumnIDMasks=NULL
int Variation_15();
// @cmember E_INVALIDARG: pcColumns=NULL
int Variation_16();
// @cmember E_INVALIDARG: ppStringsBuffer=NULL
int Variation_17();
// @cmember E_INVALIDARG: prgColumnIDs=NULL and prgColumnInfo=NULL
int Variation_18();
// @cmember E_INVALIDARG: ppStringsBuffer=NULL & either prgColumnIDs or prgColumnInfo = NULL
int Variation_19();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(GetResColInfoRow_Rowset)
#define THE_CLASS GetResColInfoRow_Rowset
BEG_TEST_CASE(GetResColInfoRow_Rowset, IColInfo, L"GetRestrictedColumnInfo on a Row object")
TEST_VARIATION(1, L"S_OK: No Masks")
TEST_VARIATION(2, L"S_OK: 1 name mask")
TEST_VARIATION(3, L"S_OK: Multiple name masks")
TEST_VARIATION(4, L"S_OK: Existing Column as mask")
TEST_VARIATION(5, L"S_OK: GUID_PROPID mask")
TEST_VARIATION(6, L"S_OK: Guid_Name mask")
TEST_VARIATION(7, L"S_OK: Pguid_Name mask")
TEST_VARIATION(8, L"S_OK: PGuid_Propid mask")
TEST_VARIATION(9, L"S_OK: Propid mask")
TEST_VARIATION(10, L"S_OK: Guid mask")
TEST_VARIATION(11, L"S_OK: prgColumnIDs=NULL but prgColumnInfo != NULL")
TEST_VARIATION(12, L"S_OK: prgColumnInfo=NULL but prgColumnIDs != NULL")
TEST_VARIATION(13, L"DB_E_BADCOLUMNID: invalid DBID for rgColumnIDMasks")
TEST_VARIATION(14, L"DB_E_NOCOLUMN: Non-existent name for mask")
TEST_VARIATION(15, L"E_INVALIDARG: cColumnIDMasks=1 and rgColumnIDMasks=NULL")
TEST_VARIATION(16, L"E_INVALIDARG: pcColumns=NULL")
TEST_VARIATION(17, L"E_INVALIDARG: ppStringsBuffer=NULL")
TEST_VARIATION(18, L"E_INVALIDARG: prgColumnIDs=NULL and prgColumnInfo=NULL")
TEST_VARIATION(19, L"E_INVALIDARG: ppStringsBuffer=NULL & either prgColumnIDs or prgColumnInfo = NULL")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(MapColID_Command)
//--------------------------------------------------------------------
// @class MapColumnIDs on a command object
//
class MapColID_Command : public IColInfo {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(MapColID_Command,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumnIDs != 0, range = NULL
int Variation_1();
// @cmember E_INVALIDARG: rgColumns is NULL
int Variation_2();
// @cmember DB_E_NOCOMMAND: CommandText is not Set
int Variation_3();
// @cmember DB_E_NOCOMMAND: CommandText is Set to Empty
int Variation_4();
// @cmember DB_E_NOCOMMAND: CommandText is Set to NULL
int Variation_5();
// @cmember DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared
int Variation_6();
// @cmember DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared
int Variation_7();
// @cmember DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
int Variation_8();
// @cmember DB_S_ERRORSOCCURRED: One ColumnID is invalid
int Variation_9();
// @cmember S_OK: Count of ColumnIDs is 0
int Variation_10();
// @cmember S_OK: Valid count and valid range of ColumnIDs
int Variation_11();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS
int Variation_12();
// @cmember S_OK: Duplicate ColumnIDs
int Variation_13();
// @cmember S_OK: ColumnIDs in reverse order
int Variation_14();
// @cmember S_OK: ColumnIDs from a view
int Variation_15();
// @cmember S_OK: ColumnIDs from a count(*)
int Variation_16();
// @cmember DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
int Variation_17();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
int Variation_18();
// @cmember DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
int Variation_19();
// @cmember DB_E_ERRORSOCCURRED: Change the GUID in the DBID
int Variation_20();
// @cmember DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
int Variation_21();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0
int Variation_22();
// @cmember DB_E_NOTABLE: Call with a Table that doesn't exist
int Variation_23();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(MapColID_Command)
#define THE_CLASS MapColID_Command
BEG_TEST_CASE(MapColID_Command, IColInfo, L"MapColumnIDs on a command object")
TEST_VARIATION(1, L"E_INVALIDARG: cColumnIDs != 0, range = NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgColumns is NULL")
TEST_VARIATION(3, L"DB_E_NOCOMMAND: CommandText is not Set")
TEST_VARIATION(4, L"DB_E_NOCOMMAND: CommandText is Set to Empty")
TEST_VARIATION(5, L"DB_E_NOCOMMAND: CommandText is Set to NULL")
TEST_VARIATION(6, L"DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared")
TEST_VARIATION(7, L"DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared")
TEST_VARIATION(8, L"DB_E_ERRORSOCCURRED: All ColumnIDs are invalid")
TEST_VARIATION(9, L"DB_S_ERRORSOCCURRED: One ColumnID is invalid")
TEST_VARIATION(10, L"S_OK: Count of ColumnIDs is 0")
TEST_VARIATION(11, L"S_OK: Valid count and valid range of ColumnIDs")
TEST_VARIATION(12, L"S_OK: Ask for DBPROP_BOOKMARKS")
TEST_VARIATION(13, L"S_OK: Duplicate ColumnIDs")
TEST_VARIATION(14, L"S_OK: ColumnIDs in reverse order")
TEST_VARIATION(15, L"S_OK: ColumnIDs from a view")
TEST_VARIATION(16, L"S_OK: ColumnIDs from a count(*)")
TEST_VARIATION(17, L"DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs")
TEST_VARIATION(18, L"DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID")
TEST_VARIATION(19, L"DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs")
TEST_VARIATION(20, L"DB_E_ERRORSOCCURRED: Change the GUID in the DBID")
TEST_VARIATION(21, L"DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal")
TEST_VARIATION(22, L"DB_E_ERRORSOCCURRED: Ask for Column 0")
TEST_VARIATION(23, L"DB_E_NOTABLE: Call with a Table that doesn't exist")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(MapColID_ExecuteRowset)
//--------------------------------------------------------------------
// @class MapColumnIDs on a rowset
//
class MapColID_ExecuteRowset : public IColInfo {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(MapColID_ExecuteRowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumnIDs != 0, range = NULL
int Variation_1();
// @cmember E_INVALIDARG: rgColumns is NULL
int Variation_2();
// @cmember DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
int Variation_3();
// @cmember DB_S_ERRORSOCCURRED: One ColumnID is invalid
int Variation_4();
// @cmember S_OK: Count of ColumnIDs is 0
int Variation_5();
// @cmember S_OK: Valid count and valid range of ColumnIDs
int Variation_6();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS
int Variation_7();
// @cmember S_OK: Duplicate ColumnIDs
int Variation_8();
// @cmember S_OK: ColumnIDs in reverse order
int Variation_9();
// @cmember S_OK: ColumnIDs from a view
int Variation_10();
// @cmember S_OK: MapColumnIDs on optional columns in IColumnsRowset
int Variation_11();
// @cmember S_OK: ColumnIDs from a count(*)
int Variation_12();
// @cmember DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
int Variation_13();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
int Variation_14();
// @cmember DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
int Variation_15();
// @cmember DB_E_ERRORSOCCURRED: Change the GUID in the DBID
int Variation_16();
// @cmember DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
int Variation_17();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0
int Variation_18();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(MapColID_ExecuteRowset)
#define THE_CLASS MapColID_ExecuteRowset
BEG_TEST_CASE(MapColID_ExecuteRowset, IColInfo, L"MapColumnIDs on a rowset")
TEST_VARIATION(1, L"E_INVALIDARG: cColumnIDs != 0, range = NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgColumns is NULL")
TEST_VARIATION(3, L"DB_E_ERRORSOCCURRED: All ColumnIDs are invalid")
TEST_VARIATION(4, L"DB_S_ERRORSOCCURRED: One ColumnID is invalid")
TEST_VARIATION(5, L"S_OK: Count of ColumnIDs is 0")
TEST_VARIATION(6, L"S_OK: Valid count and valid range of ColumnIDs")
TEST_VARIATION(7, L"S_OK: Ask for DBPROP_BOOKMARKS")
TEST_VARIATION(8, L"S_OK: Duplicate ColumnIDs")
TEST_VARIATION(9, L"S_OK: ColumnIDs in reverse order")
TEST_VARIATION(10, L"S_OK: ColumnIDs from a view")
TEST_VARIATION(11, L"S_OK: MapColumnIDs on optional columns in IColumnsRowset")
TEST_VARIATION(12, L"S_OK: ColumnIDs from a count(*)")
TEST_VARIATION(13, L"DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs")
TEST_VARIATION(14, L"DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID")
TEST_VARIATION(15, L"DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs")
TEST_VARIATION(16, L"DB_E_ERRORSOCCURRED: Change the GUID in the DBID")
TEST_VARIATION(17, L"DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal")
TEST_VARIATION(18, L"DB_E_ERRORSOCCURRED: Ask for Column 0")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(MapColID_OpenRowset)
//--------------------------------------------------------------------
// @class MapColumnIDs on a rowset
//
class MapColID_OpenRowset : public IColInfo {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(MapColID_OpenRowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember E_INVALIDARG: cColumnIDs != 0, range = NULL
int Variation_1();
// @cmember E_INVALIDARG: rgColumns is NULL
int Variation_2();
// @cmember DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
int Variation_3();
// @cmember DB_S_ERRORSOCCURRED: One ColumnID is invalid
int Variation_4();
// @cmember S_OK: Count of ColumnIDs is 0
int Variation_5();
// @cmember S_OK: Valid count and valid range of ColumnIDs
int Variation_6();
// @cmember S_OK: Ask for DBPROP_BOOKMARKS
int Variation_7();
// @cmember S_OK: MapColumnIDs on optional columns in IColumnsRowset
int Variation_8();
// @cmember DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
int Variation_9();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
int Variation_10();
// @cmember DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
int Variation_11();
// @cmember DB_E_ERRORSOCCURRED: Change the GUID in the DBID
int Variation_12();
// @cmember DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs with Bookmarks
int Variation_13();
// @cmember DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
int Variation_14();
// @cmember DB_E_ERRORSOCCURRED: Ask for Column 0
int Variation_15();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(MapColID_OpenRowset)
#define THE_CLASS MapColID_OpenRowset
BEG_TEST_CASE(MapColID_OpenRowset, IColInfo, L"MapColumnIDs on a rowset")
TEST_VARIATION(1, L"E_INVALIDARG: cColumnIDs != 0, range = NULL")
TEST_VARIATION(2, L"E_INVALIDARG: rgColumns is NULL")
TEST_VARIATION(3, L"DB_E_ERRORSOCCURRED: All ColumnIDs are invalid")
TEST_VARIATION(4, L"DB_S_ERRORSOCCURRED: One ColumnID is invalid")
TEST_VARIATION(5, L"S_OK: Count of ColumnIDs is 0")
TEST_VARIATION(6, L"S_OK: Valid count and valid range of ColumnIDs")
TEST_VARIATION(7, L"S_OK: Ask for DBPROP_BOOKMARKS")
TEST_VARIATION(8, L"S_OK: MapColumnIDs on optional columns in IColumnsRowset")
TEST_VARIATION(9, L"DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs")
TEST_VARIATION(10, L"DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID")
TEST_VARIATION(11, L"DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs")
TEST_VARIATION(12, L"DB_E_ERRORSOCCURRED: Change the GUID in the DBID")
TEST_VARIATION(13, L"DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs with Bookmarks")
TEST_VARIATION(14, L"DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal")
TEST_VARIATION(15, L"DB_E_ERRORSOCCURRED: Ask for Column 0")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(MapColIDRow_Rowset)
//*-----------------------------------------------------------------------
// @class MapColumnIDs on a Row object
//
class MapColIDRow_Rowset : public IColInfo {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(MapColIDRow_Rowset,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember S_OK: cColumnIDs = 0
int Variation_1();
// @cmember S_OK: All columns returned by GetColInfo
int Variation_2();
// @cmember S_OK: Subset of columns returned by GetColInfo
int Variation_3();
// @cmember S_OK: Columns out of order
int Variation_4();
// @cmember DB_S_ERRORSOCCURRED: One ColumnID is invalid
int Variation_5();
// @cmember DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
int Variation_6();
// @cmember E_INVALIDARG: cColumnIDs=1, rgColumnIDs=NULL
int Variation_7();
// @cmember E_INVALIDARG: rgColumns is NULL
int Variation_8();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(MapColIDRow_Rowset)
#define THE_CLASS MapColIDRow_Rowset
BEG_TEST_CASE(MapColIDRow_Rowset, IColInfo, L"MapColumnIDs on a Row object")
TEST_VARIATION(1, L"S_OK: cColumnIDs = 0")
TEST_VARIATION(2, L"S_OK: All columns returned by GetColInfo")
TEST_VARIATION(3, L"S_OK: Subset of columns returned by GetColInfo")
TEST_VARIATION(4, L"S_OK: Columns out of order")
TEST_VARIATION(5, L"DB_S_ERRORSOCCURRED: One ColumnID is invalid")
TEST_VARIATION(6, L"DB_E_ERRORSOCCURRED: All ColumnIDs are invalid")
TEST_VARIATION(7, L"E_INVALIDARG: cColumnIDs=1, rgColumnIDs=NULL")
TEST_VARIATION(8, L"E_INVALIDARG: rgColumns is NULL")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ZombieClassCmd)
//--------------------------------------------------------------------
// @class zombie on command
//
class ZombieClassCmd : public Zombie {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ZombieClassCmd,Zombie);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Abort with fRetaining set to TRUE
int Variation_1();
// @cmember Abort with fRetaining set to FALSE
int Variation_2();
// @cmember Commit with fRetaining set to TRUE
int Variation_3();
// @cmember Commit with fRetaining set to FALSE
int Variation_4();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(ZombieClassCmd)
#define THE_CLASS ZombieClassCmd
BEG_TEST_CASE(ZombieClassCmd, Zombie, L"zombie on command")
TEST_VARIATION(1, L"Abort with fRetaining set to TRUE")
TEST_VARIATION(2, L"Abort with fRetaining set to FALSE")
TEST_VARIATION(3, L"Commit with fRetaining set to TRUE")
TEST_VARIATION(4, L"Commit with fRetaining set to FALSE")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ZombieClassRowset)
//--------------------------------------------------------------------
// @class zombie on a rowset
//
class ZombieClassRowset : public Zombie {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ZombieClassRowset,Zombie);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Abort with fRetaining set to TRUE
int Variation_1();
// @cmember Abort with fRetaining set to FALSE
int Variation_2();
// @cmember Commit with fRetaining set to TRUE
int Variation_3();
// @cmember Commit with fRetaining set to FALSE
int Variation_4();
// @cmember Abort with fRetaining set to TRUE for Multiple Rowsets
int Variation_5();
// @cmember Abort with fRetaining set to FALSE for Multiple Rowsets
int Variation_6();
// @cmember Commit with fRetaining set to TRUE for Multiple Rowsets
int Variation_7();
// @cmember Commit with fRetaining set to FALSE for Multiple Rowsets
int Variation_8();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(ZombieClassRowset)
#define THE_CLASS ZombieClassRowset
BEG_TEST_CASE(ZombieClassRowset, Zombie, L"zombie on a rowset")
TEST_VARIATION(1, L"Abort with fRetaining set to TRUE")
TEST_VARIATION(2, L"Abort with fRetaining set to FALSE")
TEST_VARIATION(3, L"Commit with fRetaining set to TRUE")
TEST_VARIATION(4, L"Commit with fRetaining set to FALSE")
TEST_VARIATION(5, L"Abort with fRetaining set to TRUE for Multiple Rowsets")
TEST_VARIATION(6, L"Abort with fRetaining set to FALSE for Multiple Rowsets")
TEST_VARIATION(7, L"Commit with fRetaining set to TRUE for Multiple Rowsets")
TEST_VARIATION(8, L"Commit with fRetaining set to FALSE for Multiple Rowsets")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ZombieClassRow)
//*-----------------------------------------------------------------------
// @class zombie on a row
//
class ZombieClassRow : public Zombie {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ZombieClassRow,Zombie);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Abort with fRetaining set to TRUE
int Variation_1();
// @cmember Abort with fRetaining set to FALSE
int Variation_2();
// @cmember Commit with fRetaining set to TRUE
int Variation_3();
// @cmember Commit with fRetaining set to FALSE
int Variation_4();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(ZombieClassRow)
#define THE_CLASS ZombieClassRow
BEG_TEST_CASE(ZombieClassRow, Zombie, L"zombie on a row")
TEST_VARIATION(1, L"Abort with fRetaining set to TRUE")
TEST_VARIATION(2, L"Abort with fRetaining set to FALSE")
TEST_VARIATION(3, L"Commit with fRetaining set to TRUE")
TEST_VARIATION(4, L"Commit with fRetaining set to FALSE")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(ExtendedErrors)
//--------------------------------------------------------------------
// @class extended error tests
//
class ExtendedErrors : public IColInfo {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(ExtendedErrors,IColInfo);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Valid IColumnsInfo calls on the Command with previous error object existing
int Variation_1();
// @cmember Invalid IColumnsInfo calls on the Command with previous eror object existing
int Variation_2();
// @cmember Invalid IColumnsInfo calls on the Command with no previous error object existing
int Variation_3();
// @cmember Valid IColumnsInfo calls on the Rowset with previous error object existing
int Variation_4();
// @cmember Invalid IColumnsInfo calls on the Rowset with previous error object exisiting
int Variation_5();
// @cmember Invalid IColumnsInfo calls on the Rowset with no previous error object exisiting
int Variation_6();
// }} TCW_TESTVARS_END
};
// {{ TCW_TESTCASE(ExtendedErrors)
#define THE_CLASS ExtendedErrors
BEG_TEST_CASE(ExtendedErrors, IColInfo, L"extended error tests")
TEST_VARIATION(1, L"Valid IColumnsInfo calls on the Command with previous error object existing")
TEST_VARIATION(2, L"Invalid IColumnsInfo calls on the Command with previous eror object existing")
TEST_VARIATION(3, L"Invalid IColumnsInfo calls on the Command with no previous error object existing")
TEST_VARIATION(4, L"Valid IColumnsInfo calls on the Rowset with previous error object existing")
TEST_VARIATION(5, L"Invalid IColumnsInfo calls on the Rowset with previous error object exisiting")
TEST_VARIATION(6, L"Invalid IColumnsInfo calls on the Rowset with no previous error object exisiting")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
////////////////////////////////////////////////////////////////////////
// Copying Test Cases to make duplicate ones.
//
////////////////////////////////////////////////////////////////////////
#define COPY_TEST_CASE(theClass, baseClass) \
class theClass : public baseClass \
{ \
public: \
static const WCHAR m_wszTestCaseName[]; \
DECLARE_TEST_CASE_FUNCS(theClass, baseClass); \
}; \
const WCHAR theClass::m_wszTestCaseName[] = { L#theClass }; \
#define TEST_CASE_WITH_PARAM(iCase, theClass, param) \
case iCase: \
pCTestCase = new theClass(NULL); \
((theClass*)pCTestCase)->SetTestCaseParam(param); \
pCTestCase->SetOwningMod(iCase-1, pCThisTestModule); \
return pCTestCase;
//2
COPY_TEST_CASE(GetColInfoRow_Cmd, GetColInfoRow_Rowset)
COPY_TEST_CASE(MapColIDRow_Cmd, MapColIDRow_Rowset)
COPY_TEST_CASE(GetResColInfoRow_Cmd, GetResColInfoRow_Rowset)
//3
COPY_TEST_CASE(GetColInfoRow_OpenRW, GetColInfoRow_Rowset)
COPY_TEST_CASE(MapColIDRow_OpenRW, MapColIDRow_Rowset)
COPY_TEST_CASE(GetResColInfoRow_OpenRW, GetResColInfoRow_Rowset)
//4
COPY_TEST_CASE(GetColInfoRow_Bind, GetColInfoRow_Rowset)
COPY_TEST_CASE(MapColIDRow_Bind, MapColIDRow_Rowset)
COPY_TEST_CASE(GetResColInfoRow_Bind, GetResColInfoRow_Rowset)
//5
COPY_TEST_CASE(GetColInfoRow_IColInfo2, GetColInfoRow_Rowset)
COPY_TEST_CASE(MapColIDRow_IColInfo2, MapColIDRow_Rowset)
COPY_TEST_CASE(GetColInfo_SingSel, GetColInfo_Command)
COPY_TEST_CASE(MapColID_SingSel, MapColID_Command)
//NOTE: The #ifdef block below is only for test wizard. TestWizard has too many
//strict rules in the parsing code and requires a 1:1 correspondence between
//testcases and the map. What the #else section is doing is basically "reusing"
//existing testcases by just passing in a parameter which changes the behvior.
//So we make LTM think there are various cases in here with different names, but in
//reality we only have to maintain code for the unique cases.
#if 0
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(13, ThisModule, gwszModuleDescrip)
TEST_CASE(1, GetColInfo_Command)
TEST_CASE(2, GetColInfo_ExecuteRowset)
TEST_CASE(3, GetColInfo_OpenRowset)
TEST_CASE(4, GetColInfoRow_Rowset)
TEST_CASE(5, GetResColInfoRow_Rowset)
TEST_CASE(6, MapColID_Command)
TEST_CASE(7, MapColID_ExecuteRowset)
TEST_CASE(8, MapColID_OpenRowset)
TEST_CASE(9, MapColIDRow_Rowset)
TEST_CASE(10, ZombieClassCmd)
TEST_CASE(11, ZombieClassRowset)
TEST_CASE(12, ZombieClassRow)
TEST_CASE(13, ExtendedErrors)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
#else
TEST_MODULE(26, ThisModule, gwszModuleDescrip)
TEST_CASE_WITH_PARAM(1, GetColInfo_Command, TC_Cmd)
TEST_CASE_WITH_PARAM(2, GetColInfo_SingSel, TC_SingSel)
TEST_CASE(3, GetColInfo_ExecuteRowset)
TEST_CASE(4, GetColInfo_OpenRowset)
TEST_CASE(5, GetColInfoRow_Rowset)
TEST_CASE_WITH_PARAM(6, GetColInfoRow_Cmd, TC_Cmd)
TEST_CASE_WITH_PARAM(7, GetColInfoRow_OpenRW, TC_OpenRW)
TEST_CASE_WITH_PARAM(8, GetColInfoRow_Bind, TC_Bind)
TEST_CASE_WITH_PARAM(9, GetColInfoRow_IColInfo2, TC_IColInfo2)
TEST_CASE(10, GetResColInfoRow_Rowset)
TEST_CASE_WITH_PARAM(11, GetResColInfoRow_Cmd, TC_Cmd)
TEST_CASE_WITH_PARAM(12, GetResColInfoRow_OpenRW, TC_OpenRW)
TEST_CASE_WITH_PARAM(13, GetResColInfoRow_Bind, TC_Bind)
TEST_CASE_WITH_PARAM(14, MapColID_Command, TC_Cmd)
TEST_CASE_WITH_PARAM(15, MapColID_SingSel, TC_SingSel)
TEST_CASE(16, MapColID_ExecuteRowset)
TEST_CASE(17, MapColID_OpenRowset)
TEST_CASE(18, MapColIDRow_Rowset)
TEST_CASE_WITH_PARAM(19, MapColIDRow_Cmd, TC_Cmd)
TEST_CASE_WITH_PARAM(20, MapColIDRow_OpenRW, TC_OpenRW)
TEST_CASE_WITH_PARAM(21, MapColIDRow_Bind, TC_Bind)
TEST_CASE_WITH_PARAM(22, MapColIDRow_IColInfo2, TC_IColInfo2)
TEST_CASE(23, ZombieClassCmd)
TEST_CASE(24, ZombieClassRowset)
TEST_CASE(25, ZombieClassRow)
TEST_CASE(26, ExtendedErrors)
END_TEST_MODULE()
#endif
// {{ TCW_TC_PROTOTYPE(GetColInfo_Command)
//*-----------------------------------------------------------------------
//| Test Case: GetColInfo_Command - IColumnsInfo on a command object
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_Command::Init()
{
// Initialize for IColumnsInfo::GetColumnInfo
m_Method = GETCOLINFO;
ULONG_PTR ulOleObj = 0;
if(!GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
GetModInfo()->GetThisTestModule()->m_pIUnknown, &ulOleObj) ||
!(ulOleObj & DBPROPVAL_OO_SINGLETON))
{
if(m_eTestCase == TC_SingSel)
{
odtLog<<L"INFO: Obtaining row objects directly from commands is not supported.\n";
return TEST_SKIPPED;
}
}
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(COMMAND_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_1()
{
TBEGIN;
// Initialize the variation
INIT;
// Set text on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL),S_OK);
// Prepare the Statement
if( m_ePreparation == SUPPORTED ) {
TESTC_(m_hr=PrepareCommand(m_pICommand,PREPARE,1),S_OK);
}
if(m_eTestCase == TC_SingSel)
{
TESTC(GetRowIColumnsInfo(m_pICommand, (IUnknown**)&m_pIColumnsInfo))
}
else
{
TESTC(VerifyInterface(m_pICommand, IID_IColumnsInfo,
COMMAND_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
}
// Dirty the output params
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer = INVALID(WCHAR*);
// Run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(NULL, &m_rgInfo,
&m_pStringsBuffer), E_INVALIDARG);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgInfo is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_2()
{
TBEGIN;
// Initialize the variation
INIT;
// Set text on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL),S_OK);
// Prepare the Statement
if( m_ePreparation == SUPPORTED ) {
TESTC_(m_hr=PrepareCommand(m_pICommand,PREPARE,1),S_OK);
}
if(m_eTestCase == TC_SingSel)
{
TESTC(GetRowIColumnsInfo(m_pICommand, (IUnknown**)&m_pIColumnsInfo))
}
else
{
TESTC(VerifyInterface(m_pICommand, IID_IColumnsInfo,
COMMAND_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
}
// Dirty the output params
m_cColumns = 99;
m_pStringsBuffer = INVALID(WCHAR*);
// Run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
NULL, &m_pStringsBuffer), E_INVALIDARG);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: pStringsBuffer is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_3()
{
TBEGIN;
// Initialize the variation
INIT;
// Set text on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL),S_OK);
// Prepare the Statement
if( m_ePreparation == SUPPORTED ) {
TESTC_(m_hr=PrepareCommand(m_pICommand,PREPARE,1),S_OK);
}
if(m_eTestCase == TC_SingSel)
{
TESTC(GetRowIColumnsInfo(m_pICommand, (IUnknown**)&m_pIColumnsInfo))
}
else
{
TESTC(VerifyInterface(m_pICommand, IID_IColumnsInfo,
COMMAND_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
}
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
// Run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, NULL), E_INVALIDARG);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is not Set
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_4()
{
TBEGIN;
// Initialize the variation
INIT;
if(m_eTestCase == TC_SingSel)
goto CLEANUP; //skip test.
TESTC(VerifyInterface(m_pICommand, IID_IColumnsInfo,
COMMAND_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
// Validate return code
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer), DB_E_NOCOMMAND);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is Set to Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_5()
{
TBEGIN;
WCHAR * pSQLSet = NULL;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSQL,
SELECT_ALLFROMTBL, pSQLSet, NEITHER, 1), DB_E_NOCOMMAND);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is Set to NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_6()
{
TBEGIN;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSQL,
SELECT_ALLFROMTBL, NULL, NEITHER, 1), DB_E_NOCOMMAND);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_7()
{
TBEGIN;
HRESULT Exphr = S_OK;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
// Check to see if the Provider supports ICommandPrepare
if( m_ePreparation == SUPPORTED )
Exphr = DB_E_NOTPREPARED;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, BOTH, 1), Exphr);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_8()
{
TBEGIN;
HRESULT Exphr = S_OK;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
// Check to see if the Provider supports ICommandPrepare
if( m_ePreparation == SUPPORTED )
Exphr = DB_E_NOTPREPARED;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1), Exphr);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set and Prepared
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_9()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1,
0, (m_eTestCase==TC_SingSel)), S_OK);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText includes duplicate columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_10()
{
TBEGIN;
// Initialize the variation
INIT;
// Run testing interface, validate params
TEST2C_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_DUPLICATECOLUMNS, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), S_OK, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED)
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set, then change the Text
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_11()
{
TBEGIN;
HRESULT hr=E_FAIL;
// Initialize the variation
INIT;
// Set text on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL),S_OK);
// Prepare the Statement
if( m_ePreparation == SUPPORTED ) {
TESTC_(m_hr=PrepareCommand(m_pICommand,PREPARE,1),S_OK);
}
// Set text on command
TEST2C_(hr = SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_REVCOLLIST, NULL),S_OK, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(hr != DB_E_NOTSUPPORTED)
// Prepare the Statement
if( m_ePreparation == SUPPORTED ) {
TESTC_(m_hr=PrepareCommand(m_pICommand,PREPARE,1),S_OK);
}
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), S_OK);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a count(*)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_12()
{
TBEGIN;
// Initialize the variation
INIT;
TEST2C_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COUNT, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), S_OK, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED);
// Validate the columns
CheckEachColumn(m_hr,0,SELECT_COUNT);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains different column names
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_13()
{
TBEGIN;
// Initialize the variation
INIT;
TEST2C_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_CHANGECOLNAME, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), S_OK, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED)
// Validate the columns
CheckEachColumn(m_hr,0,SELECT_CHANGECOLNAME);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a insert statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_14()
{
TBEGIN;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
//If the provider is read only, skip the variation.
if( g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE )
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
INSERT_1ROW, NULL, PREPARE), S_OK);
// Validate the columns
CheckEachColumn(m_hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a select from an Empty Rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_15()
{
TBEGIN;
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if(m_eTestCase==TC_SingSel)
{
IRow* pIRow = NULL;
hr=SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
eSELECT,SELECT_EMPTYROWSET,NULL,NULL,NULL);
//Skip variation if query is not supported.
TESTC_PROVIDER(hr != DB_E_NOTSUPPORTED)
CHECK(hr, S_OK);
if(m_ePreparation == SUPPORTED)
COMPARE(SUCCEEDED(PrepareCommand(m_pICommand,PREPARE,0)), TRUE);
CHECK(m_pICommand->Execute(NULL, IID_IRow, NULL, NULL, (IUnknown**)&pIRow), DB_E_NOTFOUND);
SAFE_RELEASE(pIRow);
FREE;
return TEST_PASS;
}
TEST2C_(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_EMPTYROWSET, NULL, PREPARE), S_OK, DB_E_NOTSUPPORTED)
//Skip variation if query is not supported.
TESTC_PROVIDER(hr != DB_E_NOTSUPPORTED)
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Base table contains no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_16()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
ULONG cRows = 0;
// Initialize the variation
INIT;
//Check to see if the DSO is ReadOnly
//Commands are required for Delete
if(!g_fReadOnlyProvider && m_pTable->GetSQLSupport() != DBPROPVAL_SQL_NONE)
{
// Delete all rows in the table.
if (!CHECK(m_pTable->Delete(),S_OK))
goto CLEANUP;
}
else
{
// Drop the table and create an empty one
if (!CHECK(m_pTable->DropTable(),S_OK))
goto CLEANUP;
if (!SUCCEEDED(m_pTable->CreateTable(0,1,NULL,PRIMARY,TRUE)))
goto CLEANUP;
}
if(m_eTestCase==TC_SingSel)
{
IRow* pIRow = NULL;
TEST2C_(hr=SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
eSELECT,SELECT_EMPTYROWSET,NULL,NULL,NULL), S_OK, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
if(hr == DB_E_NOTSUPPORTED)
{
FREE;
return TEST_SKIPPED;
}
if(m_ePreparation == SUPPORTED)
COMPARE(SUCCEEDED(PrepareCommand(m_pICommand,PREPARE,0)), TRUE);
CHECK(m_pICommand->Execute(NULL, IID_IRow, NULL, NULL, (IUnknown**)&pIRow), DB_E_NOTFOUND);
SAFE_RELEASE(pIRow);
FREE;
return TEST_PASS;
}
if (CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT, SELECT_COLLISTFROMTBL, NULL, PREPARE), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
for(cRows=0;cRows<10;cRows++)
m_pTable->Insert();
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a update statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_17()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
//If the provider is read only, skip the variation.
if(g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE)
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eUPDATE,
SELECT_EMPTYROWSET, NULL, PREPARE), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a delete statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_18()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
//If the provider is read only, skip the variation.
if(g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE)
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eDELETE,
SELECT_EMPTYROWSET, NULL, PREPARE);
if (CHECK(hr, S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_19()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"IRowsetLocate is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1, DBPROP_IRowsetLocate), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_IRowsetLocate);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_20()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1, DBPROP_BOOKMARKS), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,DBPROP_BOOKMARKS);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS on a Insert Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_21()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
//If the provider is read only, skip the variation.
if(g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE)
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
INSERT_1ROW, NULL, PREPARE, 1, DBPROP_BOOKMARKS);
if (CHECK(hr, S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,DBPROP_BOOKMARKS);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_DEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_22()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_DEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1, DBPROP_DEFERRED), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,DBPROP_DEFERRED);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_23()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_CACHEDEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Cache Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1, DBPROP_CACHEDEFERRED), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,DBPROP_CACHEDEFERRED);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_24()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_MAYWRITECOLUMN, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"May Write Column is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1, DBPROP_MAYWRITECOLUMN), S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,DBPROP_MAYWRITECOLUMN);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a select from view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_25()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
//If the provider is read only, skip the variation.
if(g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE)
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLISTFROMVIEW, NULL, PREPARE);
// Check to see if the create view failed
if (FAILED(hr))
{
odtLog<<L"Create view not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement with Column List
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_26()
{
TBEGIN;
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
if (!SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
TEST2C_(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_ALL_WITH_SEARCHABLE_AND_UPDATEABLE,
NULL, PREPARE, 1, DBPROP_BOOKMARKS), S_OK, DB_E_NOTSUPPORTED)
//Skip variation if query is not supported.
TESTC_PROVIDER(hr != DB_E_NOTSUPPORTED)
// Validate the columns
CheckEachColumn(hr,DBPROP_BOOKMARKS);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a LEFT OUTER JOIN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_27()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
// Check the SQL Support of the Provider
if( !(m_pTable->GetSQLSupport() & DBPROPVAL_SQL_ODBC_CORE) )
{
odtLog << L"Provider does not support outer joins." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_LEFTOUTERJOIN, NULL, PREPARE);
// Check to see if the left outer joins work
if (FAILED(hr))
{
odtLog<<L"Left Outer Joins not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr, 0, SELECT_LEFTOUTERJOIN);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a RIGHT OUTER JOIN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_28()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Check the SQL Support of the Provider
if( !(m_pTable->GetSQLSupport() & DBPROPVAL_SQL_ODBC_CORE) )
{
odtLog << L"Provider does not support outer joins." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if(m_eTestCase==TC_SingSel)
{
IRow* pIRow = NULL;
CHECK(hr=SetCommandText(m_pIMalloc,m_pICommand,m_pTable,m_pTable2->GetTableName(),
eSELECT,SELECT_RIGHTOUTERJOIN,NULL,NULL,NULL), S_OK);
if(m_ePreparation == SUPPORTED)
COMPARE(SUCCEEDED(PrepareCommand(m_pICommand,PREPARE,0)), TRUE);
hr = m_pICommand->Execute(NULL, IID_IRow, NULL, NULL, (IUnknown**)&pIRow);
COMPARE((hr==DB_E_NOTFOUND) || (hr==DB_E_ERRORSINCOMMAND), TRUE);
SAFE_RELEASE(pIRow);
FREE;
return TEST_PASS;
}
hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_RIGHTOUTERJOIN, NULL, PREPARE);
// Check to see if the right outer joins work
if (FAILED(hr))
{
odtLog<<L"Right Outer Joins not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr, 0, SELECT_RIGHTOUTERJOIN);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTABLE: Call with a Table that doesn't exist
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_Command::Variation_29()
{
TBEGIN;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
// Initialize the variation
INIT;
TEST3C_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_NO_TABLE, NULL, PREPARE), DB_E_NOTABLE, DB_E_ERRORSINCOMMAND, DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED)
// Validate the columns
CheckEachColumn(m_hr, 0, SELECT_NO_TABLE);
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_Command::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetColInfo_ExecuteRowset)
//*-----------------------------------------------------------------------
//| Test Case: GetColInfo_ExecuteRowset - IColumnsInfo on a rowset object
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_ExecuteRowset::Init()
{
// Initialize for IColumnsInfo::GetColumnInfo
m_Method = GETCOLINFO;
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(COMMAND_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_1()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
// SetText on command
if (FAILED(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL)))
goto CLEANUP;
if (!CHECK(hr=m_pICommand->Execute(NULL, iid, NULL, &m_cRowsAffected,
(IUnknown **) &m_pIRowset),S_OK))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
// Release the IColumnsInfo Pointer
SAFE_RELEASE(m_pIColumnsInfo);
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
// Run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(NULL, &m_rgInfo,
&m_pStringsBuffer), E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgInfo is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_2()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
// SetText on command
if (FAILED(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL)))
goto CLEANUP;
if (!CHECK(hr=m_pICommand->Execute(NULL, iid, NULL, &m_cRowsAffected,
(IUnknown **) &m_pIRowset),S_OK))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
// Release the ColumnsInfo Pointer
SAFE_RELEASE(m_pIColumnsInfo);
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_cColumns = 99;
m_pStringsBuffer= INVALID(WCHAR*);
// Run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, NULL,
&m_pStringsBuffer),E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: pStringsBuffer is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_3()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
// SetText on command
if (FAILED(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL)))
goto CLEANUP;
if (!CHECK(hr=m_pICommand->Execute(NULL, iid, NULL, &m_cRowsAffected,
(IUnknown **) &m_pIRowset),S_OK))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
// Release the ColumnsInfo Pointer
SAFE_RELEASE(m_pIColumnsInfo);
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
NULL),E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set and Executed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_4()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, NEITHER, 0),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set, Prepared, Unprepared, and Executed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_5()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, BOTH, 0),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set, Prepared, and Executed
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_6()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_ALLFROMTBL, NULL, PREPARE, 1),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText that includes duplicate columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_7()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_DUPLICATECOLUMNS, NULL, NEITHER, 1),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText is Set, then change the Text
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_8()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (!CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_DUPLICATECOLUMNS, NULL, NEITHER, 1),S_OK))
goto CLEANUP;
SAFE_RELEASE(m_pIRowset);
SAFE_RELEASE(m_pIColumnsInfo);
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
PROVIDER_FREE(m_prgOrdTbl1);
m_cOrdTbl1 = 0;
// SetText on Command
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_REVCOLLIST, NULL, PREPARE, 1),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
if (CHECK(hr,S_OK))
fResult = TEST_PASS;
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a count(*)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_9()
{
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
TEST2C_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COUNT, NULL, NEITHER, 1),S_OK,DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
if(m_hr == DB_E_NOTSUPPORTED)
{
fResult = TEST_SKIPPED;
goto CLEANUP;
}
// Validate the columns
CheckEachColumn(m_hr,0,SELECT_COUNT);
fResult = TEST_PASS;
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains different column names
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_10()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_CHANGECOLNAME, NULL, NEITHER, 1),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr,0,SELECT_CHANGECOLNAME);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a select from an Empty Rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_11()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
TEST2C_(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_EMPTYROWSET, NULL, NEITHER, 1),S_OK,DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
if (hr == DB_E_NOTSUPPORTED)
{
odtLog<<L"Statement is not supported" <<ENDL;
fResult = TEST_SKIPPED;
goto CLEANUP;
}
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Base table contains no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_12()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
ULONG count = 0;
// Initialize the variation
INIT;
// Check to see if the DSO is ReadOnly
if(!g_fReadOnlyProvider && m_pTable->GetSQLSupport() != DBPROPVAL_SQL_NONE)
{
// Delete all rows in the table.
if(!CHECK(m_pTable->Delete(),S_OK))
goto CLEANUP;
}
else
{
// Drop the table and create an empty one
if(!CHECK(m_pTable->DropTable(),S_OK))
goto CLEANUP;
if(!SUCCEEDED(m_pTable->CreateTable(0,1,NULL,PRIMARY,TRUE)))
goto CLEANUP;
}
if(CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
for(count=0;count<10;count++)
m_pTable->Insert();
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_13()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if (!SupportedProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"IRowsetLocate is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1, DBPROP_IRowsetLocate),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_IRowsetLocate);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_14()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if (!SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1, DBPROP_BOOKMARKS),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_BOOKMARKS);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_DEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_15()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if (!SupportedProperty(DBPROP_DEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1, DBPROP_DEFERRED),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_DEFERRED);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_16()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if (!SupportedProperty(DBPROP_CACHEDEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Cache Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if (CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1, DBPROP_CACHEDEFERRED),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_CACHEDEFERRED);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_17()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
if (!SupportedProperty(DBPROP_MAYWRITECOLUMN, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"May Write Column is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
if(CHECK(hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER, 1, DBPROP_MAYWRITECOLUMN),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_MAYWRITECOLUMN);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a select from view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_18()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
//If the provider is read only, skip the variation.
if(g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE)
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_REVCOLLISTFROMVIEW, NULL, NEITHER, 1);
// Check to see if the create view failed
if (FAILED(hr))
{
odtLog<<L"Create view not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a LEFT OUTER JOIN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_19()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_LEFTOUTERJOIN, NULL, PREPARE);
// Check to see if the left outer joins work
if (FAILED(hr))
{
odtLog<<L"Left Outer Joins not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr, 0, SELECT_LEFTOUTERJOIN);
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc S_OK: CommandText contains a RIGHT OUTER JOIN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_ExecuteRowset::Variation_20()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
// Initialize the variation
INIT;
hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_RIGHTOUTERJOIN, NULL, PREPARE);
// Check to see if the right outer joins work
if (FAILED(hr))
{
odtLog<<L"Right Outer Joins not supported" <<ENDL;
fResult = TEST_PASS;
}
else
{
// Check to see if everything worked
if(CHECK(hr, S_OK))
fResult = TEST_PASS;
}
// Validate the columns
CheckEachColumn(hr, 0, SELECT_RIGHTOUTERJOIN);
FREE;
return fResult;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_ExecuteRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetColInfo_OpenRowset)
//*-----------------------------------------------------------------------
//| Test Case: GetColInfo_OpenRowset - IColumnsInfo on a rowset object
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_OpenRowset::Init()
{
// Initialize for IColumnsInfo::GetColumnInfo
m_Method = GETCOLINFO;
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(ROWSET_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_1()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_rgInfo = INVALID(DBCOLUMNINFO*);
m_pStringsBuffer= INVALID(WCHAR*);
// Run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(NULL, &m_rgInfo,
&m_pStringsBuffer), E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgInfo is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_2()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_cColumns = 99;
m_pStringsBuffer= INVALID(WCHAR*);
// Run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, NULL,
&m_pStringsBuffer),E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: pStringsBuffer is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_3()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// Dirty the output params
m_cColumns = 99;
m_rgInfo = INVALID(DBCOLUMNINFO*);
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
NULL),E_INVALIDARG))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Basic OpenRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_4()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Base table contains no rows
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_5()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
ULONG count = 0;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
// Check to see if the DSO is ReadOnly
if(!g_fReadOnlyProvider && m_pTable->GetSQLSupport() != DBPROPVAL_SQL_NONE)
{
// Delete all rows in the table.
if(!CHECK(m_pTable->Delete(),S_OK))
goto CLEANUP;
}
else
{
// Drop the table and create an empty one
if(!CHECK(m_pTable->DropTable(),S_OK))
goto CLEANUP;
if(!SUCCEEDED(m_pTable->CreateTable(0,1,NULL,PRIMARY,TRUE)))
goto CLEANUP;
}
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
goto CLEANUP;
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr);
for(count=0;count<10;count++)
m_pTable->Insert();
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_IRowsetLocate on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_6()
{
HRESULT hr = E_FAIL;
HRESULT Exphr = S_OK;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
if (!SupportedProperty(DBPROP_IRowsetLocate, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"IRowsetLocate is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_IRowsetLocate);
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
{
if(CHECK(DB_E_ERRORSOCCURRED, hr) && (!m_pIRowset) && (m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE))
fResult = TEST_PASS;
goto CLEANUP;
}
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_IRowsetLocate);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_7()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
if (!SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_BOOKMARKS);
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
{
if(CHECK(DB_E_ERRORSOCCURRED, hr) && (!m_pIRowset) && (m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE))
fResult = TEST_PASS;
goto CLEANUP;
}
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_BOOKMARKS);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_DEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_8()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
if (!SupportedProperty(DBPROP_DEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_DEFERRED);
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
{
if(CHECK(DB_E_ERRORSOCCURRED, hr) && (!m_pIRowset) && (m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE))
fResult = TEST_PASS;
goto CLEANUP;
}
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_DEFERRED);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_CACHEDEFERRED on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_9()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
if (!SupportedProperty(DBPROP_CACHEDEFERRED, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"Cache Deferred is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_CACHEDEFERRED);
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
{
if(CHECK(DB_E_ERRORSOCCURRED, hr) && (!m_pIRowset) && (m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE))
fResult = TEST_PASS;
goto CLEANUP;
}
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_DEFERRED);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_MAYWRITECOLUMN on a Select Statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfo_OpenRowset::Variation_10()
{
HRESULT hr = E_FAIL;
BOOL fResult = TEST_FAIL;
IID iid = IID_IRowset;
if (!SupportedProperty(DBPROP_MAYWRITECOLUMN, DBPROPSET_ROWSET, m_pIDBInitialize))
{
odtLog << L"May Write Column is not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_MAYWRITECOLUMN);
if (FAILED(hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)))
{
if(CHECK(DB_E_ERRORSOCCURRED, hr) && (!m_pIRowset) && (m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE))
fResult = TEST_PASS;
goto CLEANUP;
}
if (!m_pIRowset)
goto CLEANUP;
if (FAILED(m_pIRowset->QueryInterface(IID_IColumnsInfo,
(void **)&m_pIColumnsInfo)))
goto CLEANUP;
// run testing interface, validate params
if (CHECK(hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK))
fResult = TEST_PASS;
// Validate the columns
CheckEachColumn(hr, DBPROP_MAYWRITECOLUMN);
CLEANUP:
FREE;
return fResult;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfo_OpenRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(GetColInfoRow_Rowset)
//*-----------------------------------------------------------------------
//| Test Case: GetColInfoRow_Rowset - GetColumnInfo on a Row object
//| Created: 10/12/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetColInfoRow_Rowset::Init()
{
EINTERFACE eIntf = ROWSET_INTERFACE;
if(m_eTestCase == TC_Cmd)
eIntf = COMMAND_INTERFACE;
// {{ TCW_INIT_BASECLASS_CHECK
if(IColInfo::Init(eIntf))
// }}
{
m_Method = GETCOLINFO;
switch(m_eTestCase)
{
case TC_Rowset:
return GetRowFromRowset(FALSE);
case TC_Cmd:
return GetRowFromCommand(FALSE);
case TC_OpenRW:
return GetRowFromOpenRW(FALSE);
case TC_Bind:
return GetRowFromBind(FALSE);
case TC_IColInfo2:
return GetRowFromRowset(TRUE);
default:
ASSERT(!L"Unhandled Type...");
}
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Basic
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfoRow_Rowset::Variation_1()
{
TBEGIN
TESTC_(m_hr=CallMethodOnRowObj(FALSE), S_OK)
m_cColumns = m_cOrdTbl1 + !(m_rgInfo2[0].iOrdinal) ;
m_rgInfo = m_rgInfo2;
CheckEachColumn(m_hr);
TESTC(m_cColumns2 >= m_cColumns)
TESTC(CheckRowSpecificColumns(m_cColumns2-m_cColumns,
&(m_rgInfo2[m_cColumns]), m_rgInfo2[m_cColumns-1].iOrdinal+1))
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: pcColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfoRow_Rowset::Variation_2()
{
TBEGIN
if(m_pIColumnsInfo)
TESTC_(m_pIColumnsInfo->GetColumnInfo(NULL,&m_rgInfo2,&m_pStringsBuffer), E_INVALIDARG)
else
TESTC_(m_pIColumnsInfo2->GetColumnInfo(NULL,&m_rgInfo2,&m_pStringsBuffer), E_INVALIDARG)
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: prgInfo is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfoRow_Rowset::Variation_3()
{
TBEGIN
if(m_pIColumnsInfo)
TESTC_(m_pIColumnsInfo->GetColumnInfo(&m_cColumns2,NULL,&m_pStringsBuffer), E_INVALIDARG)
else
TESTC_(m_pIColumnsInfo2->GetColumnInfo(&m_cColumns2,NULL,&m_pStringsBuffer), E_INVALIDARG)
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: ppStringsBuffer is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetColInfoRow_Rowset::Variation_4()
{
TBEGIN
if(m_pIColumnsInfo)
TESTC_(m_pIColumnsInfo->GetColumnInfo(&m_cColumns2,&m_rgInfo2,NULL), E_INVALIDARG)
else
TESTC_(m_pIColumnsInfo2->GetColumnInfo(&m_cColumns2,&m_rgInfo2,NULL), E_INVALIDARG)
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL GetColInfoRow_Rowset::Terminate()
{
SAFE_RELEASE(m_pIUnknown);
FREE;
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(GetResColInfoRow_Rowset)
//*-----------------------------------------------------------------------
//| Test Case: GetResColInfoRow_Rowset - GetRestrictedColumnInfo on a Row object
//| Created: 10/12/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL GetResColInfoRow_Rowset::Init()
{
EINTERFACE eIntf = ROWSET_INTERFACE;
if(m_eTestCase == TC_Cmd)
eIntf = COMMAND_INTERFACE;
// {{ TCW_INIT_BASECLASS_CHECK
if(IColInfo::Init(eIntf))
// }}
{
m_Method = GETRESCOLINFO;
switch(m_eTestCase)
{
case TC_Rowset:
return GetRowFromRowset(TRUE);
case TC_Cmd:
return GetRowFromCommand(TRUE);
case TC_OpenRW:
return GetRowFromOpenRW(TRUE);
case TC_Bind:
return GetRowFromBind(TRUE);
default:
ASSERT(!L"Unhandled Type...");
}
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK: No Masks
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_1()
{
TBEGIN
//NO MASKS.
m_cMasks = 0;
m_rgMasks = NULL;
TESTC_(m_hr=CallMethodOnRowObj(TRUE), S_OK)
m_cColumns = m_cOrdTbl1 + !(m_rgInfo2[0].iOrdinal) ;
m_rgInfo = m_rgInfo2;
CheckEachColumn(m_hr);
TESTC(m_cColumns2 >= m_cColumns)
TESTC(CheckRowSpecificColumns(m_cColumns2-m_cColumns,
&(m_rgInfo2[m_cColumns]), m_rgInfo2[m_cColumns-1].iOrdinal+1))
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc S_OK: 1 name mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_2()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"C";
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Multiple name masks
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_3()
{
TBEGIN
DBORDINAL iMask;
DBORDINAL cMasks = 8;
//6 NAME MASKS
m_cMasks = cMasks;
SAFE_ALLOC(m_rgMasks, DBID, cMasks);
for(iMask=0; iMask<cMasks; iMask++)
m_rgMasks[iMask].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"C";
m_rgMasks[1].uName.pwszName = L"c";
m_rgMasks[2].uName.pwszName = L"R";
m_rgMasks[3].uName.pwszName = L"r";
m_rgMasks[4].uName.pwszName = L"S";
m_rgMasks[5].uName.pwszName = L"s";
m_rgMasks[6].uName.pwszName = L"D";
m_rgMasks[7].uName.pwszName = L"h";
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Existing Column as mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_4()
{
TBEGIN
DBORDINAL cCol = 0;
TESTC_(m_hr=CallMethodOnRowObj(TRUE, GETCOLINFO), S_OK)
TESTC(m_cColumns2>0 && m_rgInfo2)
if(m_cColumns2>1)
cCol = 1;
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
TESTC_(DuplicateDBID(m_rgInfo2[cCol].columnid, m_rgMasks), S_OK)
FreeColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
TESTC_(m_hr=CallMethodOnRowObj(TRUE), S_OK)
TESTC(VerifyRestrictions());
CLEANUP:
ReleaseDBID(m_rgMasks, FALSE);
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc S_OK: GUID_PROPID mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_5()
{
TBEGIN
ULONG_PTR ulDocSrc=0;
BOOL bDocSrc=FALSE;
//Get the value of DBPROP_DATASOURCE_TYPE property.
if(GetProperty(DBPROP_DATASOURCE_TYPE, DBPROPSET_DATASOURCEINFO,
m_pIDBInitialize, &ulDocSrc))
{
if((ulDocSrc & DBPROPVAL_DST_DOCSOURCE) == DBPROPVAL_DST_DOCSOURCE)
bDocSrc = TRUE;
}
//6 GUID MASKS
m_cMasks = 6;
SAFE_ALLOC(m_rgMasks, DBID, 6);
m_rgMasks[0] = DBROWCOL_PARSENAME;
m_rgMasks[1] = DBROWCOL_PARENTNAME;
m_rgMasks[2] = DBROWCOL_ABSOLUTEPARSENAME;
m_rgMasks[3] = DBROWCOL_ISHIDDEN;
m_rgMasks[4] = DBROWCOL_ISREADONLY;
m_rgMasks[5] = DBROWCOL_CONTENTTYPE;
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
{
TESTC(VerifyRestrictions());
//Since the resource rowset columns were returned,
//verify the value of DBPROP_DATASOURCE_TYPE property.
TESTC(bDocSrc);
odtLog<<L"INFO: This provider supports direct URL binding and is a document source provider.\n";
}
else
{
TESTC(!bDocSrc);
odtLog<<L"INFO: This provider is NOT a document source provider.\n";
}
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Guid_Name mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_6()
{
TBEGIN
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_GUID_NAME;
m_rgMasks[0].uGuid.guid = guidMod;
m_rgMasks[0].uName.pwszName = L"C";
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Pguid_Name mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_7()
{
TBEGIN
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_PGUID_NAME;
m_rgMasks[0].uGuid.pguid = &guidMod;
m_rgMasks[0].uName.pwszName = L"C";
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK: PGuid_Propid mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_8()
{
TBEGIN
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_PGUID_PROPID;
m_rgMasks[0].uGuid.pguid = &guidMod;
m_rgMasks[0].uName.ulPropid = 2;
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Propid mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_9()
{
TBEGIN
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_PROPID;
m_rgMasks[0].uName.ulPropid = 2;
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Guid mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_10()
{
TBEGIN
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_GUID;
m_rgMasks[0].uGuid.guid = guidMod;
TEST2C_(m_hr=CallMethodOnRowObj(TRUE), S_OK, DB_E_NOCOLUMN)
if(S_OK == m_hr)
TESTC(VerifyRestrictions());
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK: prgColumnIDs=NULL but prgColumnInfo != NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_11()
{
TBEGIN
DBORDINAL cCol = 0;
TESTC_(m_hr=CallMethodOnRowObj(TRUE, GETCOLINFO), S_OK)
TESTC(m_cColumns2>0 && m_rgInfo2)
if(m_cColumns2>1)
cCol = 1;
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
TESTC_(DuplicateDBID(m_rgInfo2[cCol].columnid, m_rgMasks), S_OK)
FreeColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
TESTC_(m_hr = m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks,
m_rgMasks, 0, &m_cColumns2,NULL,&m_rgInfo2,&m_pStringsBuffer), S_OK)
TESTC(CheckParams(m_hr, GETRESCOLINFO))
TESTC(VerifyRestrictions());
CLEANUP:
ReleaseDBID(m_rgMasks, FALSE);
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc S_OK: prgColumnInfo=NULL but prgColumnIDs != NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_12()
{
TBEGIN
DBORDINAL cCol = 0;
TESTC_(m_hr=CallMethodOnRowObj(TRUE, GETCOLINFO), S_OK)
TESTC(m_cColumns2>0 && m_rgInfo2)
if(m_cColumns2>1)
cCol = 1;
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
TESTC_(DuplicateDBID(m_rgInfo2[cCol].columnid, m_rgMasks), S_OK)
FreeColumnInfo(&m_cColumns2,&m_rgInfo2,&m_pStringsBuffer);
TESTC_(m_hr = m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks,
m_rgMasks, 0, &m_cColumns2,&m_rgColumnIDs2,NULL,&m_pStringsBuffer), S_OK)
TESTC(CheckParams(m_hr, GETRESCOLINFO))
TESTC(VerifyRestrictions());
CLEANUP:
ReleaseDBID(m_rgMasks, FALSE);
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc DB_E_BADCOLUMNID: invalid DBID for rgColumnIDMasks
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_13()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_GUID + 100; //Some large number.
m_rgMasks[0].uName.pwszName = L"n";
TESTC_(m_hr=CallMethodOnRowObj(TRUE), DB_E_BADCOLUMNID)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOLUMN: Non-existent name for mask
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_14()
{
TBEGIN
DBORDINAL iMask;
//6 NAME MASKS
m_cMasks = 6;
SAFE_ALLOC(m_rgMasks, DBID, 6);
for(iMask=0; iMask<6; iMask++)
m_rgMasks[iMask].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"NonExistentColumn1";
m_rgMasks[1].uName.pwszName = L"NonExistentColumn2";
m_rgMasks[2].uName.pwszName = L"NonExistentColumn3";
m_rgMasks[3].uName.pwszName = L"NonExistentColumn4";
m_rgMasks[4].uName.pwszName = L"NonExistentColumn5";
m_rgMasks[5].uName.pwszName = L"NonExistentColumn6";
TESTC_(m_hr=CallMethodOnRowObj(TRUE), DB_E_NOCOLUMN)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumnIDMasks=1 and rgColumnIDMasks=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_15()
{
TBEGIN
TESTC_(m_pIColumnsInfo2->GetRestrictedColumnInfo(1, NULL, 0, &m_cColumns2,&m_rgColumnIDs2,&m_rgInfo2,&m_pStringsBuffer), E_INVALIDARG)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: pcColumns=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_16()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"n";
TESTC_(m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks, 0, NULL,&m_rgColumnIDs2,&m_rgInfo2,&m_pStringsBuffer), E_INVALIDARG)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: ppStringsBuffer=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_17()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"n";
TESTC_(m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks, 0, &m_cColumns2,&m_rgColumnIDs2,&m_rgInfo2,NULL), E_INVALIDARG)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: prgColumnIDs=NULL and prgColumnInfo=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_18()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"n";
TESTC_(m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks,
0, &m_cColumns2,NULL,NULL,&m_pStringsBuffer), E_INVALIDARG)
TESTC_(m_pIColumnsInfo2->GetRestrictedColumnInfo(0, m_rgMasks, 0,
&m_cColumns2,NULL,NULL,NULL), E_INVALIDARG)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: ppStringsBuffer=NULL & either prgColumnIDs or prgColumnInfo = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int GetResColInfoRow_Rowset::Variation_19()
{
TBEGIN
//ONE NAME MASK
m_cMasks = 1;
SAFE_ALLOC(m_rgMasks, DBID, 1);
m_rgMasks[0].eKind = DBKIND_NAME;
m_rgMasks[0].uName.pwszName = L"n";
CHECK(m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks,
0, &m_cColumns2,NULL, &m_rgInfo2, NULL), E_INVALIDARG);
CHECK(m_pIColumnsInfo2->GetRestrictedColumnInfo(m_cMasks, m_rgMasks,
0, &m_cColumns2,&m_rgColumnIDs2,NULL,NULL), E_INVALIDARG);
CHECK(m_pIColumnsInfo2->GetRestrictedColumnInfo(0, m_rgMasks,
0, &m_cColumns2,NULL,&m_rgInfo2,NULL), E_INVALIDARG);
CHECK(m_pIColumnsInfo2->GetRestrictedColumnInfo(0, m_rgMasks,
0, &m_cColumns2,&m_rgColumnIDs2,NULL,NULL), E_INVALIDARG);
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL GetResColInfoRow_Rowset::Terminate()
{
SAFE_RELEASE(m_pIUnknown);
FREE;
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(MapColID_Command)
//*-----------------------------------------------------------------------
//| Test Case: MapColID_Command - MapColumnIDs on a command object
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_Command::Init()
{
// Initialize for IColumnsInfo::MapColumnIDs
m_Method = MAPCOLID;
ULONG_PTR ulOleObj = 0;
if(!GetProperty(DBPROP_OLEOBJECTS, DBPROPSET_DATASOURCEINFO,
GetModInfo()->GetThisTestModule()->m_pIUnknown, &ulOleObj) ||
!(ulOleObj & DBPROPVAL_OO_SINGLETON))
{
if(m_eTestCase == TC_SingSel)
{
odtLog<<L"INFO: Obtaining row objects directly from commands is not supported.\n";
return TEST_SKIPPED;
}
}
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(COMMAND_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumnIDs != 0, range = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_1()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, FALSE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),E_INVALIDARG);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_2()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),E_INVALIDARG);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is not Set
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_3()
{
TBEGIN;
DBORDINAL ulIndex = 0;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Initialize to Params
m_cColumnIDs = 1;
m_rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * m_cColumnIDs);
m_rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * m_cColumnIDs);
// Check the pointers and memset to invalid signature
TESTC(m_rgColumnIDs != NULL);
TESTC(m_rgColumns != NULL);
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
TESTC(VerifyInterface(m_pICommand, IID_IColumnsInfo,
COMMAND_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Validate return code
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,
m_rgColumns), DB_E_NOCOMMAND);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is Set to Empty
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_4()
{
TBEGIN;
DBORDINAL ulIndex = 0;
WCHAR * pSQLSet = NULL;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Fillout the Columns
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// SetText on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSQL, SELECT_COLLISTFROMTBL, pSQLSet),S_OK);
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,
m_rgColumns), DB_E_NOCOMMAND);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOCOMMAND: CommandText is Set to NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_5()
{
TBEGIN;
DBORDINAL ulIndex = 0;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Fillout the Columns
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// SetText on command
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSQL, SELECT_COLLISTFROMTBL, NULL),S_OK);
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,
m_rgColumns), DB_E_NOCOMMAND);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTPREPARED/S_OK: CommandText is Set, but not Prepared
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_6()
{
TBEGIN;
HRESULT Exphr = S_OK;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Check to see if the Provider supports ICommandPrepare
if( m_ePreparation == SUPPORTED )
Exphr = DB_E_NOTPREPARED;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLIST, NULL, NEITHER, 1), Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTPREPARED/S_OK: CommandText is Set, Prepared, and Unprepared
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_7()
{
TBEGIN;
HRESULT Exphr = S_OK;
if(m_eTestCase==TC_SingSel)
goto CLEANUP;
// Initialize the variation
INIT;
// Check to see if the Provider supports ICommandPrepare
if( m_ePreparation == SUPPORTED )
Exphr = DB_E_NOTPREPARED;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, BOTH, 1), Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_8()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
// Initialize to Params
m_cColumnIDs = 5;
m_rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * m_cColumnIDs);
m_rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * m_cColumnIDs);
TESTC(m_rgColumnIDs != NULL);
TESTC(m_rgColumns != NULL);
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumns[ulIndex] = 55;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: One ColumnID is invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_9()
{
TBEGIN;
HRESULT Exphr = S_OK;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( !ulIndex )
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Count of ColumnIDs is 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_10()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Valid count and valid range of ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_11()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_12()
{
TBEGIN;
if( !SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize) )
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1, DBPROP_BOOKMARKS,(m_eTestCase==TC_SingSel)),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Duplicate ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_13()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_DUPLICATECOLUMNS, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs in reverse order
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_14()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLIST, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs from a view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_15()
{
TBEGIN;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
//If the provider is read only, skip the variation.
if( g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE )
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLISTFROMVIEW, NULL, PREPARE);
// Check to see if the create view failed
if( FAILED(m_hr) )
odtLog<<L"Create view not supported" <<ENDL;
else {
TESTC_(m_hr, S_OK);
}
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs from a count(*)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_16()
{
TBEGIN;
// Initialize the variation
INIT;
TEST2C_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COUNT, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK,DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_17()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( (m_rgColumnIDs[ulIndex].eKind == DBKIND_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_GUID_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_PGUID_NAME) )
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1;
}
else
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
m_rgColumnIDs[ulIndex].uName.pwszName = L"Bogus";
}
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_18()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_19()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_NAME;
break;
case DBKIND_GUID_NAME:
case DBKIND_PGUID_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
break;
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
case DBKIND_GUID_PROPID:
case DBKIND_PGUID_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
break;
case DBKIND_GUID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
default:
assert(FALSE);
}
}
CHECKW(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr, FALSE));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the GUID in the DBID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_20()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_PGUID_NAME:
case DBKIND_PGUID_PROPID:
*m_rgColumnIDs[ulIndex].uGuid.pguid = DBPROPSET_ROWSET;
break;
case DBKIND_NAME:
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID;
case DBKIND_GUID:
case DBKIND_GUID_NAME:
case DBKIND_GUID_PROPID:
m_rgColumnIDs[ulIndex].uGuid.guid = DBPROPSET_ROWSET;
break;
}
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_21()
{
TBEGIN;
HRESULT Exphr = S_OK;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( !ulIndex )
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = ULONG(m_cColumnIDs+2);
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
TESTC_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_22()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel)),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE,1,
0,(m_eTestCase==TC_SingSel));
// May or may not find the bookmark column
if( GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pICommand) ) {
TEST2C_(m_hr, DB_E_ERRORSOCCURRED, DB_S_ERRORSOCCURRED);
}
else {
TESTC_(m_hr, DB_E_ERRORSOCCURRED);
}
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc DB_E_NOTABLE: Call with a Table that doesn't exist
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_Command::Variation_23()
{
TBEGIN;
DBORDINAL ulIndex = 0;
if(m_eTestCase==TC_SingSel)
return TEST_SKIPPED;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
TEST3C_(m_hr=ExecuteMethod_cmd(FALSE, FALSE, FALSE, eSELECT,
SELECT_NO_TABLE, NULL, PREPARE), DB_E_NOTABLE, DB_E_ERRORSINCOMMAND,DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED)
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_Command::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(MapColID_ExecuteRowset)
//*-----------------------------------------------------------------------
//| Test Case: MapColID_ExecuteRowset - MapColumnIDs on a rowset
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_ExecuteRowset::Init()
{
// Initialize for IColumnsInfo::MapColumnIDs
m_Method = MAPCOLID;
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(COMMAND_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumnIDs != 0, range = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_1()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, FALSE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),E_INVALIDARG);
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_2()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),E_INVALIDARG);
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_3()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
// Initialize to Params
m_cColumnIDs = 5;
m_rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * m_cColumnIDs);
m_rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * m_cColumnIDs);
TESTC(m_rgColumnIDs != NULL);
TESTC(m_rgColumns != NULL);
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumns[ulIndex] = 55;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
}
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: One ColumnID is invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_4()
{
TBEGIN;
HRESULT Exphr = S_OK;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( !ulIndex )
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
// Check to see if there is only one column
if( m_cColumnIDs == 1 )
Exphr = DB_E_ERRORSOCCURRED;
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Count of ColumnIDs is 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_5()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(FALSE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Valid count and valid range of ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_6()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_7()
{
TBEGIN;
if( !SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize) )
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER,1, DBPROP_BOOKMARKS),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Duplicate ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_8()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_DUPLICATECOLUMNS, NULL, NEITHER),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs in reverse order
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_9()
{
TBEGIN;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLIST, NULL, NEITHER),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs from a view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_10()
{
TBEGIN;
//If the provider is read only, skip the variation.
if( g_fReadOnlyProvider || m_pTable->GetSQLSupport() == DBPROPVAL_SQL_NONE )
{
odtLog << L"Provider is ReadOnly." << ENDL;
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_REVCOLLISTFROMVIEW, NULL, PREPARE);
// Check to see if the create view failed
if( FAILED(m_hr) )
odtLog<<L"Create view not supported" <<ENDL;
else {
TESTC_(m_hr, S_OK);
}
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK: MapColumnIDs on optional columns in IColumnsRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_11()
{
TBEGIN;
DBORDINAL ulOptColOrd = 99;
DBORDINAL cOptColumns = 0;
DBID* rgOptColumns = NULL;
IColumnsRowset* pIColumnsRowset = NULL;
IRowset* pIRowsetColumns = NULL;
// Initialize the variation
INIT;
// SetText on command and get a Rowset
TESTC_(SetCommandText(m_pIMalloc, m_pICommand, m_pTable,
NULL, eSELECT, SELECT_COLLISTFROMTBL, NULL),S_OK);
TESTC_(m_pICommand->Execute(NULL,IID_IRowset,NULL,
NULL,(IUnknown **)&m_pIRowset),S_OK);
// Check to see if IColumnsRowset is supported
TESTC_PROVIDER(VerifyInterface(m_pIRowset, IID_IColumnsRowset,
ROWSET_INTERFACE, (IUnknown **)&pIColumnsRowset));
TESTC_(pIColumnsRowset->GetAvailableColumns(&cOptColumns,
&rgOptColumns),S_OK);
// Check for an optional column
TESTC_PROVIDER(cOptColumns && rgOptColumns);
// Pass first optional column
TESTC_(pIColumnsRowset->GetColumnsRowset(NULL, 1, rgOptColumns,
IID_IRowset, 0, NULL, (IUnknown**)&pIRowsetColumns),S_OK);
// Get a IID_IColumnsInfo pointer
TESTC(VerifyInterface(pIRowsetColumns, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer), S_OK);
TESTC_(m_pIColumnsInfo->MapColumnIDs(1, rgOptColumns,
&ulOptColOrd),S_OK);
TESTC(m_rgInfo[m_cColumns-1].iOrdinal == ulOptColOrd);
CLEANUP:
PROVIDER_FREE(rgOptColumns);
SAFE_RELEASE(pIColumnsRowset);
SAFE_RELEASE(pIRowsetColumns);
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc S_OK: ColumnIDs from a count(*)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_12()
{
TBEGIN;
// Initialize the variation
INIT;
TEST2C_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COUNT, NULL, NEITHER),S_OK,DB_E_NOTSUPPORTED);
//Skip variation if query is not supported.
TESTC_PROVIDER(m_hr != DB_E_NOTSUPPORTED)
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_13()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( (m_rgColumnIDs[ulIndex].eKind == DBKIND_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_GUID_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_PGUID_NAME) )
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1;
}
else
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
m_rgColumnIDs[ulIndex].uName.pwszName = L"Bogus";
}
}
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_14()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_15()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_NAME;
break;
case DBKIND_GUID_NAME:
case DBKIND_PGUID_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
break;
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
case DBKIND_GUID_PROPID:
case DBKIND_PGUID_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
break;
case DBKIND_GUID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
default:
assert(FALSE);
}
}
CHECKW(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr, FALSE));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the GUID in the DBID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_16()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_PGUID_NAME:
case DBKIND_PGUID_PROPID:
*m_rgColumnIDs[ulIndex].uGuid.pguid = DBPROPSET_ROWSET;
break;
case DBKIND_NAME:
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID;
case DBKIND_GUID:
case DBKIND_GUID_NAME:
case DBKIND_GUID_PROPID:
m_rgColumnIDs[ulIndex].uGuid.guid = DBPROPSET_ROWSET;
break;
}
}
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, NEITHER), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_17()
{
TBEGIN;
HRESULT Exphr = S_OK;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( !ulIndex )
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = ULONG(m_cColumnIDs+2);
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
// Check to see if there is only one column
if( m_cColumnIDs == 1 )
Exphr = DB_E_ERRORSOCCURRED;
TESTC_(m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_ExecuteRowset::Variation_18()
{
TBEGIN;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK);
// Release the Rowset created
SAFE_RELEASE(m_pIRowset);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
m_hr=ExecuteMethod_row(FALSE, FALSE, FALSE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE);
// May or may not find the bookmark column
if( GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pICommand) ) {
TEST2C_(m_hr, DB_E_ERRORSOCCURRED, DB_S_ERRORSOCCURRED);
}
else {
TESTC_(m_hr, DB_E_ERRORSOCCURRED);
}
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_ExecuteRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(MapColID_OpenRowset)
//*-----------------------------------------------------------------------
//| Test Case: MapColID_OpenRowset - MapColumnIDs on a rowset
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_OpenRowset::Init()
{
// Initialize for IColumnsInfo::MapColumnIDs
m_Method = MAPCOLID;
// {{ TCW_INIT_BASECLASS_CHECK
return IColInfo::Init(ROWSET_INTERFACE);
// }}
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumnIDs != 0, range = NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_1()
{
TBEGIN;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,FALSE,TRUE),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),E_INVALIDARG);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_2()
{
TBEGIN;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,FALSE),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),E_INVALIDARG);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_3()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
// Initialize to Params
m_cColumnIDs = 5;
m_rgColumnIDs = (DBID *) PROVIDER_ALLOC(sizeof(DBID) * m_cColumnIDs);
m_rgColumns = (DBORDINAL *) PROVIDER_ALLOC(sizeof(DBORDINAL) * m_cColumnIDs);
TESTC(m_rgColumnIDs != NULL);
TESTC(m_rgColumns != NULL);
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumns[ulIndex] = 55;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
}
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: One ColumnID is invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_4()
{
TBEGIN;
HRESULT Exphr = S_OK;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( !ulIndex )
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = 1000;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Count of ColumnIDs is 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_5()
{
TBEGIN;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(FALSE,TRUE,TRUE),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Valid count and valid range of ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_6()
{
TBEGIN;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Ask for DBPROP_BOOKMARKS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_7()
{
TBEGIN;
IID iid = IID_IRowset;
if( !SupportedProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize) )
{
odtLog << L"Bookmarks are not supported.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_BOOKMARKS);
if( FAILED(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset)) )
{
TESTC_(DB_E_ERRORSOCCURRED, m_hr);
TESTC(!m_pIRowset);
TESTC(m_rgPropSets->rgProperties->dwStatus == DBPROPSTATUS_NOTSETTABLE);
goto CLEANUP;
}
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(FALSE,TRUE,TRUE),S_OK);
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns),S_OK);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK: MapColumnIDs on optional columns in IColumnsRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_8()
{
TBEGIN;
DBORDINAL ulOptColOrd = 99;
DBORDINAL cOptColumns = 0;
DBID* rgOptColumns = NULL;
IColumnsRowset* pIColumnsRowset = NULL;
IRowset* pIRowsetColumns = NULL;
IID iid = IID_IRowset;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
// Check to see if IColumnsRowset is supported
TESTC_PROVIDER(VerifyInterface(m_pIRowset, IID_IColumnsRowset,
ROWSET_INTERFACE, (IUnknown **)&pIColumnsRowset));
TESTC_(pIColumnsRowset->GetAvailableColumns(&cOptColumns,
&rgOptColumns),S_OK);
// Check for an optional column
TESTC_PROVIDER(cOptColumns && rgOptColumns);
// Pass first optional column
TESTC_(pIColumnsRowset->GetColumnsRowset(NULL, 1, rgOptColumns,
IID_IRowset, 0, NULL, (IUnknown**)&pIRowsetColumns),S_OK);
// Get a IID_IColumnsInfo pointer
TESTC(VerifyInterface(pIRowsetColumns, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer), S_OK);
TESTC_(m_pIColumnsInfo->MapColumnIDs(1, rgOptColumns,
&ulOptColOrd),S_OK);
TESTC(m_rgInfo[m_cColumns-1].iOrdinal == ulOptColOrd);
CLEANUP:
PROVIDER_FREE(rgOptColumns);
SAFE_RELEASE(pIColumnsRowset);
SAFE_RELEASE(pIRowsetColumns);
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_9()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( (m_rgColumnIDs[ulIndex].eKind == DBKIND_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_GUID_NAME) ||
(m_rgColumnIDs[ulIndex].eKind == DBKIND_PGUID_NAME) )
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1;
}
else
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
m_rgColumnIDs[ulIndex].uName.pwszName = L"Bogus";
}
}
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0 with DBKIND_PROPID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_10()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_11()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_NAME;
break;
case DBKIND_GUID_NAME:
case DBKIND_PGUID_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
break;
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
case DBKIND_GUID_PROPID:
if(m_rgColumnIDs[ulIndex].uGuid.guid == DBCOL_SPECIALCOL)
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
break;
case DBKIND_PGUID_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
break;
case DBKIND_GUID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
default:
assert(FALSE);
}
}
// run testing interface, validate params
CHECKW(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr, FALSE));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Change the GUID in the DBID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_12()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_PGUID_NAME:
case DBKIND_PGUID_PROPID:
*m_rgColumnIDs[ulIndex].uGuid.pguid = DBPROPSET_ROWSET;
break;
case DBKIND_NAME:
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID;
case DBKIND_GUID:
case DBKIND_GUID_NAME:
case DBKIND_GUID_PROPID:
m_rgColumnIDs[ulIndex].uGuid.guid = DBPROPSET_ROWSET;
break;
}
}
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Switch the DBKIND in the ColumnIDs with Bookmarks
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_13()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Set Property
if( !SettableProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIDBInitialize) )
{
odtLog << L"Bookmarks are not settable.\n";
return TEST_SKIPPED;
}
// Initialize the variation
INIT;
// Set Property
SetRowsetProperties(DBPROPSET_ROWSET,DBPROP_BOOKMARKS);
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
switch(m_rgColumnIDs[ulIndex].eKind)
{
case DBKIND_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_NAME;
break;
case DBKIND_GUID_NAME:
case DBKIND_PGUID_NAME:
m_rgColumnIDs[ulIndex].eKind = DBKIND_NAME;
break;
case DBKIND_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
case DBKIND_GUID_PROPID:
case DBKIND_PGUID_PROPID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
break;
case DBKIND_GUID:
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
break;
default:
assert(FALSE);
}
}
// run testing interface, validate params
CHECKW(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), DB_E_ERRORSOCCURRED);
// Validate the columns
QTESTC(CheckOrdinal(m_hr, FALSE));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: ColumnID one greater than the last ordinal
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_14()
{
TBEGIN;
HRESULT Exphr = S_OK;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if (!ulIndex)
{
// Check to see if there is only one column
Exphr = DB_E_ERRORSOCCURRED;
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = ULONG(m_cColumnIDs+2);
continue;
}
// Check to see if there is more than one column
Exphr = DB_S_ERRORSOCCURRED;
}
// run testing interface, validate params
TESTC_(m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), Exphr);
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: Ask for Column 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColID_OpenRowset::Variation_15()
{
TBEGIN;
IID iid = IID_IRowset;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
TESTC_(m_hr=m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(),
NULL, iid, m_cPropSets, m_rgPropSets, (IUnknown **)&m_pIRowset),S_OK);
TESTC(m_pIRowset != NULL);
TESTC(VerifyInterface(m_pIRowset, IID_IColumnsInfo,
ROWSET_INTERFACE, (IUnknown **)&m_pIColumnsInfo));
// Get the Column DBIDs
TESTC_(m_hr=m_pIColumnsInfo->GetColumnInfo(&m_cColumns, &m_rgInfo,
&m_pStringsBuffer),S_OK);
// Make array of DBIDs
TESTC_(m_hr=MakeDBIDArrays(TRUE,TRUE,TRUE),S_OK);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if( m_rgColumnIDs[ulIndex].eKind != DBKIND_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_GUID_PROPID &&
m_rgColumnIDs[ulIndex].eKind != DBKIND_PGUID_PROPID )
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID_PROPID;
m_rgColumnIDs[ulIndex].uName.ulPropid = 0;
}
// run testing interface, validate params
m_hr=m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs, m_rgColumnIDs, m_rgColumns);
// May or may not find the bookmark column
if( GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, m_pIRowset) ) {
TEST2C_(m_hr, DB_E_ERRORSOCCURRED, DB_S_ERRORSOCCURRED);
}
else {
TESTC_(m_hr, DB_E_ERRORSOCCURRED);
}
// Validate the columns
QTESTC(CheckOrdinal(m_hr));
CLEANUP:
FREE;
TRETURN;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColID_OpenRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(MapColIDRow_Rowset)
//*-----------------------------------------------------------------------
//| Test Case: MapColIDRow_Rowset - MapColumnIDs on a Row object
//| Created: 10/12/98
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL MapColIDRow_Rowset::Init()
{
EINTERFACE eIntf = ROWSET_INTERFACE;
if(m_eTestCase == TC_Cmd)
eIntf = COMMAND_INTERFACE;
// {{ TCW_INIT_BASECLASS_CHECK
if(IColInfo::Init(eIntf))
// }}
{
m_Method = MAPCOLID;
switch(m_eTestCase)
{
case TC_Rowset:
return GetRowFromRowset(FALSE);
case TC_Cmd:
return GetRowFromCommand(FALSE);
case TC_OpenRW:
return GetRowFromOpenRW(FALSE);
case TC_Bind:
return GetRowFromBind(FALSE);
case TC_IColInfo2:
return GetRowFromRowset(TRUE);
default:
ASSERT(!L"Unhandled Type...");
}
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK: cColumnIDs = 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_1()
{
TBEGIN
m_cColumnIDs = 0;
SAFE_ALLOC(m_rgColumnIDs, DBID, 1);
SAFE_ALLOC(m_rgColumns, DBORDINAL, 1);
TESTC_(m_hr=CallMethodOnRowObj(FALSE), S_OK)
TESTC(m_rgColumnIDs != NULL)
TESTC(m_rgColumns != NULL)
CLEANUP:
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc S_OK: All columns returned by GetColInfo
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_2()
{
TBEGIN
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
m_cColumns = m_cColumns2;
m_rgInfo = m_rgInfo2;
TESTC_(MakeDBIDArrays(TRUE,TRUE,TRUE), S_OK)
TESTC_(m_hr=CallMethodOnRowObj(FALSE), S_OK)
QTESTC(CheckOrdinal(m_hr))
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Subset of columns returned by GetColInfo
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_3()
{
TBEGIN
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
TESTC_PROVIDER(m_cColumns2>2)
m_cColumns = m_cColumns2 - 2;
m_rgInfo = &(m_rgInfo2[2]);
TESTC_(MakeDBIDArrays(TRUE,TRUE,TRUE), S_OK)
TESTC_(m_hr=CallMethodOnRowObj(FALSE), S_OK)
QTESTC(CheckOrdinal(m_hr))
TESTC(m_rgColumns[0] == m_rgInfo2[2].iOrdinal)
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc S_OK: Columns out of order
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_4()
{
TBEGIN
DBORDINAL ulIndex = 0;
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
TESTC_PROVIDER(m_cColumns2>2)
m_cColumns = m_cColumns2;
m_rgInfo = m_rgInfo2;
m_cColumnIDs = 2;
// Allocate memory for the array of DBID's
SAFE_ALLOC(m_rgColumnIDs, DBID, sizeof(DBID) * m_cColumnIDs);
// Copy DBIDs using DuplicateDBID, not memcpy
DuplicateDBID(m_rgInfo2[2].columnid, &(m_rgColumnIDs[0]));
DuplicateDBID(m_rgInfo2[0].columnid, &(m_rgColumnIDs[1]));
// Allocate memory for the array of DBID's
SAFE_ALLOC(m_rgColumns, DBORDINAL, sizeof(DBORDINAL) * m_cColumnIDs);
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = DB_INVALIDCOLUMN;
TESTC_(m_hr=CallMethodOnRowObj(FALSE), S_OK)
QTESTC(CheckOrdinal(m_hr))
TESTC(m_rgColumns[0] == m_rgInfo2[2].iOrdinal)
TESTC(m_rgColumns[1] == m_rgInfo2[0].iOrdinal)
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED: One ColumnID is invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_5()
{
TBEGIN
DBORDINAL ulIndex;
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
m_cColumns = m_cColumns2;
m_rgInfo = m_rgInfo2;
TESTC_(MakeDBIDArrays(TRUE,TRUE,TRUE), S_OK)
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
if (!ulIndex)
{
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID + 100;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
}
}
TEST2C_(m_hr=CallMethodOnRowObj(FALSE), DB_S_ERRORSOCCURRED, DB_E_ERRORSOCCURRED)
// Check to see if there is only one column
if (m_cColumnIDs == 1)
TESTC_(m_hr, DB_E_ERRORSOCCURRED);
QTESTC(CheckOrdinal(m_hr))
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED: All ColumnIDs are invalid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_6()
{
TBEGIN
DBORDINAL ulIndex;
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
m_cColumns = m_cColumns2;
m_rgInfo = m_rgInfo2;
TESTC_(MakeDBIDArrays(TRUE,TRUE,TRUE), S_OK)
// Copy values into members
for(ulIndex=0; ulIndex<m_cColumnIDs; ulIndex++)
{
m_rgColumnIDs[ulIndex].uGuid.guid = GUID_NULL;
m_rgColumnIDs[ulIndex].eKind = DBKIND_GUID + 100;
m_rgColumnIDs[ulIndex].uName.ulPropid = 1000;
}
TESTC_(m_hr=CallMethodOnRowObj(FALSE), DB_E_ERRORSOCCURRED)
QTESTC(CheckOrdinal(m_hr))
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: cColumnIDs=1, rgColumnIDs=NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_7()
{
TBEGIN
if(m_pIColumnsInfo)
TESTC_(m_pIColumnsInfo->MapColumnIDs(1,NULL,m_rgColumns), E_INVALIDARG)
else
TESTC_(m_pIColumnsInfo2->MapColumnIDs(1,NULL,m_rgColumns), E_INVALIDARG)
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG: rgColumns is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int MapColIDRow_Rowset::Variation_8()
{
TBEGIN
TESTC_(m_hr=CallMethodOnRowObj(FALSE, GETCOLINFO), S_OK)
m_cColumns = m_cColumns2;
m_rgInfo = m_rgInfo2;
TESTC_(MakeDBIDArrays(TRUE,TRUE,TRUE), S_OK)
if(m_pIColumnsInfo)
TESTC_(m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,NULL), E_INVALIDARG)
else
TESTC_(m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,m_rgColumnIDs,NULL), E_INVALIDARG)
CLEANUP:
CLEAR
Free(FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL MapColIDRow_Rowset::Terminate()
{
SAFE_RELEASE(m_pIUnknown);
FREE;
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(ZombieClassCmd)
//*-----------------------------------------------------------------------
//| Test Case: ZombieClassCmd - zombie on command
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ZombieClassCmd::Init()
{
BOOL fReturn = FALSE;
// Check to see if Transactions are usable
if(!IsUsableInterface(SESSION_INTERFACE, IID_ITransactionLocal))
return TEST_SKIPPED;
// Initialize to a invalid pointer
m_pITransactionLocal = INVALID(ITransactionLocal*);
m_pIDBCreateCommand = INVALID(IDBCreateCommand*);
// {{ TCW_INIT_BASECLASS_CHECK
if(Zombie::Init())
// }}
{
//This is a mandatory interface, it should always succeed
if(RegisterInterface(COMMAND_INTERFACE, IID_IColumnsInfo, 0, NULL))
return TRUE;
}
// Check to see if ITransaction or Commands are supported
if( (!m_pITransactionLocal) || (!m_pIDBCreateCommand) )
fReturn = TEST_SKIPPED;
// Clear the bad pointer value
if(m_pIDBCreateCommand == INVALID(IDBCreateCommand*))
m_pIDBCreateCommand = NULL;
if(m_pITransactionLocal == INVALID(ITransactionLocal*))
m_pITransactionLocal = NULL;
return fReturn;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassCmd::Variation_1()
{
return TestTxnCmd(ETXN_ABORT, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassCmd::Variation_2()
{
return TestTxnCmd(ETXN_ABORT, FALSE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassCmd::Variation_3()
{
return TestTxnCmd(ETXN_COMMIT, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassCmd::Variation_4()
{
return TestTxnCmd(ETXN_COMMIT, FALSE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL ZombieClassCmd::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(Zombie::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(ZombieClassRowset)
//*-----------------------------------------------------------------------
//| Test Case: ZombieClassRowset - zombie on a rowset
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ZombieClassRowset::Init()
{
// Check to see if Transactions are usable
if(!IsUsableInterface(SESSION_INTERFACE, IID_ITransactionLocal))
return TEST_SKIPPED;
// Initialize to a invalid pointer
m_pITransactionLocal = INVALID(ITransactionLocal*);
// {{ TCW_INIT_BASECLASS_CHECK
if(Zombie::Init())
// }}
{
//This is a mandatory interface, it should always succeed
if(RegisterInterface(ROWSET_INTERFACE, IID_IColumnsInfo, 0, NULL))
return TRUE;
}
// Check to see if ITransaction is supported
if(!m_pITransactionLocal)
return TEST_SKIPPED;
// Clear the bad pointer value
if(m_pITransactionLocal == INVALID(ITransactionLocal*))
m_pITransactionLocal = NULL;
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_1()
{
return TestTxnRowset(ETXN_ABORT, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_2()
{
return TestTxnRowset(ETXN_ABORT, FALSE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_3()
{
return TestTxnRowset(ETXN_COMMIT, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_4()
{
return TestTxnRowset(ETXN_COMMIT, FALSE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to TRUE for Multiple Rowsets
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_5()
{
return TestTxnRowset(ETXN_ABORT, TRUE, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to FALSE for Multiple Rowsets
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_6()
{
return TestTxnRowset(ETXN_ABORT, FALSE, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to TRUE for Multiple Rowsets
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_7()
{
return TestTxnRowset(ETXN_COMMIT, TRUE, TRUE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to FALSE for Multiple Rowsets
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRowset::Variation_8()
{
return TestTxnRowset(ETXN_COMMIT, FALSE, TRUE);
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL ZombieClassRowset::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(Zombie::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(ZombieClassRow)
//*-----------------------------------------------------------------------
//| Test Case: ZombieClassRow - zombie on a row
//| Created: 1/28/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ZombieClassRow::Init()
{
// Check to see if Transactions are usable
if(!IsUsableInterface(SESSION_INTERFACE, IID_ITransactionLocal))
return TEST_SKIPPED;
// Initialize to a invalid pointer
m_pITransactionLocal = INVALID(ITransactionLocal*);
// {{ TCW_INIT_BASECLASS_CHECK
if(Zombie::Init())
// }}
{
//This is a mandatory interface, it should always succeed
if(RegisterInterface(ROW_INTERFACE, IID_IColumnsInfo, 0, NULL))
return TRUE;
//Check to see if the interface is supported (IGetRow off the Rowset)
if( m_hr == E_NOINTERFACE )
return TEST_SKIPPED;
}
// Check to see if ITransaction is supported
if(!m_pITransactionLocal)
return TEST_SKIPPED;
// Clear the bad pointer value
if(m_pITransactionLocal == INVALID(ITransactionLocal*))
m_pITransactionLocal = NULL;
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRow::Variation_1()
{
return TestTxnRow(ETXN_ABORT, TRUE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Abort with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRow::Variation_2()
{
return TestTxnRow(ETXN_ABORT, FALSE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRow::Variation_3()
{
return TestTxnRow(ETXN_COMMIT, TRUE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Commit with fRetaining set to FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ZombieClassRow::Variation_4()
{
return TestTxnRow(ETXN_COMMIT, FALSE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL ZombieClassRow::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(Zombie::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(ExtendedErrors)
//*-----------------------------------------------------------------------
//| Test Case: ExtendedErrors - extended error tests
//| Created: 09/20/96
//| Updated: 04/25/98
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL ExtendedErrors::Init()
{
BOOL fResult = TEST_SKIPPED;
ISupportErrorInfo *pISupportErrorInfo = NULL;
// {{ TCW_INIT_BASECLASS_CHECK
if(IColInfo::Init(COMMAND_INTERFACE))
// }}
{
INIT;
if(!m_pICommand)
goto CLEANUP;
if((m_pICommand->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo))== E_NOINTERFACE)
{
odtLog<<L"ISupportErrorInfo is not supported."<<ENDL;
goto CLEANUP;
}
fResult = TRUE;
}
else
return FALSE;
CLEANUP:
SAFE_RELEASE(pISupportErrorInfo);
FREE;
return fResult;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Valid IColumnsInfo calls on the Command with previous error object existing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_1()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Cause an error
m_pExtError->CauseError();
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer), S_OK))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Cause an error
m_pExtError->CauseError();
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), S_OK))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Invalid IColumnsInfo calls on the Command with previous eror object existing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_2()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Cause an error
m_pExtError->CauseError();
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, NULL), E_INVALIDARG))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Cause an error
m_pExtError->CauseError();
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, NULL), E_INVALIDARG))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Invalid IColumnsInfo calls on the Command with no previous error object existing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_3()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, NULL), E_INVALIDARG))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_cmd(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, NULL), E_INVALIDARG))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Valid IColumnsInfo calls on the Rowset with previous error object existing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_4()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Cause an error
m_pExtError->CauseError();
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, &m_pStringsBuffer), S_OK))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Cause an error
m_pExtError->CauseError();
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, m_rgColumns), S_OK))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Invalid IColumnsInfo calls on the Rowset with previous error object exisiting
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_5()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Cause an error
m_pExtError->CauseError();
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, NULL), E_INVALIDARG))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Cause an error
m_pExtError->CauseError();
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, NULL), E_INVALIDARG))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Invalid IColumnsInfo calls on the Rowset with no previous error object exisiting
//
// @rdesc TEST_PASS or TEST_FAIL
//
int ExtendedErrors::Variation_6()
{
BOOL fResult = TEST_FAIL;
HRESULT hr = E_FAIL;
DBORDINAL ulIndex = 0;
// Initialize the variation
INIT;
m_Method = GETCOLINFO;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE, 1), S_OK))
goto CLEANUP;
// Free the memory
FreeColumnInfo(&m_cColumns, &m_rgInfo, &m_pStringsBuffer);
// Do extended check following GetColumnInfo
if(CHECK(hr = m_pIColumnsInfo->GetColumnInfo(&m_cColumns,
&m_rgInfo, NULL), E_INVALIDARG))
fResult = XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
CheckEachColumn(hr);
FREE;
// Initialize the variation
INIT;
m_Method = MAPCOLID;
if (!CHECK(hr=ExecuteMethod_row(TRUE, TRUE, TRUE, eSELECT,
SELECT_COLLISTFROMTBL, NULL, PREPARE),S_OK))
goto CLEANUP;
// Reset the rgColumns array
for(ulIndex=0; ulIndex < m_cColumnIDs; ulIndex++)
m_rgColumns[ulIndex] = INVALID(DBORDINAL);
// Do extended check following MapColumnIDs
if(CHECK(hr = m_pIColumnsInfo->MapColumnIDs(m_cColumnIDs,
m_rgColumnIDs, NULL), E_INVALIDARG))
fResult &= XCHECK(m_pIColumnsInfo, IID_IColumnsInfo, hr);
// Validate the columns
QTESTC(CheckOrdinal(hr));
CLEANUP:
FREE;
if (fResult)
return TEST_PASS;
else
return TEST_FAIL;
}
// }}
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL ExtendedErrors::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(IColInfo::Terminate());
} // }}
// }}
// }}
Reference in New Issue View Git Blame Copy Permalink