//-------------------------------------------------------------------- // Microsoft OLE DB Test // // Copyright 1995-2000 Microsoft Corporation. // // @doc // // @module KAGTEST.CPP | KAGTEST source file for all test modules. // #define DBINITCONSTANTS // Must be defined to initialize constants in OLEDB.H #define INITGUID #include "modstandard.hpp" #include "KAGTEST.h" #include "extralib.h" #define STRINGSIZE 500 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Module Values // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // {{ TCW_MODULE_GLOBALS DECLARE_MODULE_CLSID = { 0x313f5420, 0xa823, 0x11d0, { 0x92, 0xd1, 0x00, 0x80, 0xc7, 0xe0, 0x4a, 0x81 }}; DECLARE_MODULE_NAME("KageraSpecificTest"); DECLARE_MODULE_OWNER("Microsoft"); DECLARE_MODULE_DESCRIP("Kagera Specific Test"); DECLARE_MODULE_VERSION(795921705); // }} BOOL g_fSqlServer = FALSE; //-------------------------------------------------------------------- // @func Module level initialization routine // // @rdesc Success or Failure // @flag TRUE | Successful initialization // @flag FALSE | Initialization problems // BOOL ModuleInit(CThisTestModule * pThisTestModule) { LPWSTR wszProviderName=NULL; //CommonModuleInit, Verify IRowset is supported, and Create a table if (!CommonModuleInit(pThisTestModule, IID_IRowset, 15)) { return FALSE; } if (wcscmp(pThisTestModule->m_pwszProviderName, g_wszKageraName)) { odtLog << L"This test only runs against the Kagera Provider.\n"; return TEST_SKIPPED; } GetProperty(DBPROP_DBMSNAME, DBPROPSET_DATASOURCEINFO, pThisTestModule->m_pIUnknown, &wszProviderName); if (wszProviderName && !wcscmp((LPWSTR)wszProviderName, L"Microsoft SQL Server")) { g_fSqlServer = TRUE; } PROVIDER_FREE(wszProviderName); return TRUE; } //-------------------------------------------------------------------- // @func Module level termination routine // // @rdesc Success or Failure // @flag TRUE | Successful initialization // @flag FALSE | Initialization problems // BOOL ModuleTerminate(CThisTestModule * pThisTestModule) { ULONG cCnt = 0; if (g_pTable) { //if an ini file is being used then delete and repopulate if(GetModInfo()->GetFileName()) { //delete all rows in the table. if(g_pTable->DeleteRows(ALLROWS) == S_OK) { // RePopulate table in case an .ini file is being used. for(cCnt=1; cCnt<=g_pTable->GetRowsOnCTable(); cCnt++) { if(g_pTable->Insert(cCnt, PRIMARY) != S_OK) { return FALSE; } } } } } return CommonModuleTerminate(pThisTestModule); } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //Base Class definition for Kagera specific test. // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // @class CKageraTest: Base class for all kagera specific test cases. class CKageraTest : public CRowsetObject { public: IDBProperties *m_pIDBProperties; IDBInitialize *m_pIDBInitialize; SQLHENV m_henv; SQLHDBC m_hdbc; SQLHSTMT m_hstmt; SQLHDBC m_hdesc; DBPROPSET *m_rgPropSets; ULONG m_cPropSets; private: BOOL InitODBC( enum STATE_ENUM eState, SQLPOINTER Value); BOOL InitOLEDB(enum STATE_ENUM eState); protected: //@cmember: interface pointer for IRowset IRowset *m_pIRowset; //@cmember: accessory handle HACCESSOR m_hAccessor; //@cmember: the size of a row DBLENGTH m_cRowSize; //@cmember: the count of binding structure DBCOUNTITEM m_cBinding; //@cmember: the array of binding strucuture DBBINDING *m_rgBinding; //@cmember: the column information DBCOLUMNINFO *m_rgInfo; //@cmember: the string buffer to hold the name WCHAR *m_pStringsBuffer; //@cmember: the pointer to the row buffer void *m_pData; //@cmember DBORDINAL m_ulTableRows; //@cmember BOOL m_bIndexExists; enum STATE_ENUM m_eState; BOOL GetMeToState( enum STATE_ENUM eState, SQLPOINTER Value); BOOL FreeState(enum STATE_ENUM eState); TESTRESULT TestGetInfo(enum GETINFO_ENUM eInfoValue); BOOL Init(); BOOL Terminate(); //@mfunc: Create a command object and set properties, execute a sql statement, // and create a rowset object. Create an accessor on the rowset BOOL GetRowsetAndAccessor ( EQUERY eSQLStmt, ULONG cProperties =0, const DBPROPID *rgProperties =NULL, DBPROPSTATUS dwPropStatus =DBPROPOPTIONS_REQUIRED , ULONG cPropertiesUnset =0, const DBPROPID *rgPropertiesUnset =NULL, BOOL fBindLongColumn =FALSE, DBACCESSORFLAGS dwAccessorFlags =DBACCESSOR_ROWDATA, DBPART dwPart =DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH, ECOLS_BOUND eColsToBind =ALL_COLS_BOUND, ECOLUMNORDER eBindingOrder =FORWARD, ECOLS_BY_REF eColsByRef =NO_COLS_BY_REF, DBTYPE dbTypeModifier =DBTYPE_EMPTY, DBORDINAL cColsToBind =0, ULONG *rgColsToBind =NULL, ECOLS_MEM_PROV_OWNED eColsMemProvOwned = NO_COLS_OWNED_BY_PROV, //@paramopt [IN] Which columns' memory is to be owned by the provider DBPARAMIO eParamIO = DBPARAMIO_NOTPARAM //@paramopt [IN] Parameter type to specify for eParmIO ); //@mfunc: release a rowset object and accessor created on it void ReleaseRowsetAndAccessor(); //@cmember CTOR CKageraTest(LPWSTR wszTestCaseName):CRowsetObject(wszTestCaseName) { m_pIDBProperties =NULL; m_pIRowset =NULL; m_hAccessor =NULL; m_cRowSize =0; m_cBinding =0; m_rgBinding =NULL; m_rgInfo =NULL; m_pStringsBuffer =NULL; m_pData =NULL; m_bIndexExists =FALSE; m_ulTableRows =0; } virtual ~CKageraTest() { // Free pIDBProperties SAFE_RELEASE(m_pIDBProperties) } }; //--------------------------------------------------------------------------- // CKageraTest::InitODBC // // @mfunc STATE_ENUM eState // SQLPOINTER Value odbc behavior to connect as // // this function brings the class obdc handles to the requested sState //--------------------------------------------------------------------------- BOOL CKageraTest::InitODBC(enum STATE_ENUM eState, SQLPOINTER Value) { SQLRETURN rc; WCHAR *pwszTemp = NULL; WCHAR *pwszTemp2 = NULL; WCHAR *pwszTemp3 = NULL; WCHAR *pwszDSN = NULL; WCHAR *pwszUID = NULL; WCHAR *pwszPWD = NULL; WCHAR *pToken = NULL; WCHAR *pwszInitODBC = NULL; BOOL fReturn = FALSE; if (!m_pwszInitString) return FALSE; // Extract DSN, UID, PWD from init string // DSN pwszTemp = (WCHAR *)PROVIDER_ALLOC((wcslen(m_pwszInitString)+1)*sizeof(WCHAR)); wcscpy(pwszTemp, m_pwszInitString); pwszTemp2 = (WCHAR *)PROVIDER_ALLOC((wcslen(m_pwszInitString)+1)*sizeof(WCHAR)); wcscpy(pwszTemp2, m_pwszInitString); pwszDSN=wcsstr(pwszTemp, L"="); pwszTemp3=wcstok(pwszTemp2, L"="); //if this is using a DSNless connection if (!wcscmp(pwszTemp3,L"PROVIDERSTRING")) { } else { pwszInitODBC = (WCHAR *)PROVIDER_ALLOC((wcslen(m_pwszInitString)+1)*sizeof(WCHAR)); wcscpy(pwszInitODBC, m_pwszInitString); pToken=wcstok(pwszInitODBC, L";"); // Always returns first string pwszDSN=wcsstr(pToken, L"="); if (!pwszDSN) goto CLEANUP; pwszDSN++; // UID pToken=wcstok(NULL, L";"); if (!pToken) goto CLEANUP; pwszUID=wcsstr(pToken, L"="); if (!pwszUID) goto CLEANUP; pwszUID++; // PWD pToken=wcstok(NULL, L";"); if (!pToken) goto CLEANUP; pwszPWD=wcsstr(pToken, L"="); if (!pwszPWD) goto CLEANUP; pwszPWD++; } if (eState != STATE_INTI_ALREADY_UNINIT) { if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_henv)) goto CLEANUP; if (SQL_SUCCESS != SQLSetEnvAttr(m_henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)Value, SQL_IS_UINTEGER)) goto CLEANUP; if (eState == STATE_NO_DSO) { fReturn=TRUE; goto CLEANUP; } if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_DBC, m_henv, &m_hdbc)) goto CLEANUP; } if (eState == STATE_UNINITIALIZED_DSO) { fReturn=TRUE; goto CLEANUP; } //if this is using a DSNless connection if (!wcscmp(pwszTemp3,L"PROVIDERSTRING")) { pwszTemp3=wcstok((pwszDSN+2), L"'"); rc = SQLDriverConnectW(m_hdbc, NULL, pwszTemp3, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT); } else { rc = SQLConnectW(m_hdbc, pwszDSN, SQL_NTS, pwszUID, SQL_NTS, pwszPWD, SQL_NTS); } if (!SQL_SUCCEEDED(rc)) goto CLEANUP; if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_STMT, m_hdbc, &m_hstmt)) { goto CLEANUP; } if (eState == STATE_INITIALIZED_DSO) { fReturn=TRUE; goto CLEANUP; } CLEANUP: SAFE_FREE(pwszTemp) SAFE_FREE(pwszTemp2) SAFE_FREE(pwszInitODBC) return fReturn; } //--------------------------------------------------------------------------- // CKageraTest::InitOLEDB // // @mfunc STATE_ENUM eState // // // this function brings Set OLEDB to the desired eState //--------------------------------------------------------------------------- BOOL CKageraTest::InitOLEDB(enum STATE_ENUM eState) { BOOL fResults = FALSE; HRESULT hr = NOERROR; if (eState != STATE_INTI_ALREADY_UNINIT) { // Get our initial connection to the provider, asking for IDBInitialize since // we must initialize before anything else // if (!SUCCEEDED(hr = CoCreateInstance( m_pThisTestModule->m_ProviderClsid, // NULL, // m_pThisTestModule->m_clsctxProvider, // IID_IDBInitialize, // (void **)&m_pIDBInitialize))) if(!SUCCEEDED(hr = GetModInfo()->CreateProvider(NULL, IID_IDBInitialize, (IUnknown**)&m_pIDBInitialize))) goto CLEANUP; // Get IDBProperties Pointer if (FAILED(m_pIDBInitialize->QueryInterface(IID_IDBProperties,(void **)&m_pIDBProperties))) goto CLEANUP; } if (eState == STATE_UNINITIALIZED_DSO) { fResults=TRUE; goto CLEANUP; } // Set the properties before we Initialize if (FAILED(m_pIDBProperties->SetProperties(m_cPropSets, m_rgPropSets))) goto CLEANUP; // Initialize (connect) m_pThisTestModule->m_pError->Validate((hr = m_pIDBInitialize->Initialize()), LONGSTRING(__FILE__), __LINE__,S_OK); if (!SUCCEEDED(hr)) { odtLog << wszInitializeFailed; goto CLEANUP; } if (eState == STATE_INITIALIZED_DSO || eState == STATE_INTI_ALREADY_UNINIT) { fResults=TRUE; goto CLEANUP; } // Requested state was invalid fResults=FALSE; CLEANUP: if (!fResults) { // Release the Data Source object we created since we've failed if (m_pThisTestModule->m_pIUnknown) m_pThisTestModule->m_pError->Compare(m_pThisTestModule->m_pIUnknown->Release()==0, LONGSTRING(__FILE__), __LINE__); } return fResults; } //--------------------------------------------------------------------------- // CKageraTest::GetMeToState // // @mfunc STATE_ENUM eState // // Set ODBC and OLEDB to the desired eState //--------------------------------------------------------------------------- BOOL CKageraTest::GetMeToState(enum STATE_ENUM eState, SQLPOINTER Value) { // Initialize OLE DB to the desired state if (!InitOLEDB(eState)) return FALSE; // Initialize the ODBC driver to the desired state if (!InitODBC(eState,(SQLPOINTER)Value)) return FALSE; // If both initializations were successful then we've achieved the // desired state. m_eState=eState; return TRUE; } //--------------------------------------------------------------------------- // CKageraTest::FreeState // // @mfunc STATE_ENUM eState // // Set ODBC and OLEDB to the desired eState //--------------------------------------------------------------------------- BOOL CKageraTest::FreeState(enum STATE_ENUM eState) { if (eState == STATE_INITIALIZED_DSO) { CHECK(m_pIDBInitialize->Uninitialize(), S_OK); COMPARE(SQLFreeHandle(SQL_HANDLE_STMT, m_hstmt), SQL_SUCCESS); COMPARE(SQLDisconnect(m_hdbc), SQL_SUCCESS); } SAFE_RELEASE(m_pIDBInitialize) SAFE_RELEASE(m_pIDBProperties) COMPARE(SQLFreeHandle(SQL_HANDLE_DBC, m_hdbc), SQL_SUCCESS); COMPARE(SQLFreeHandle(SQL_HANDLE_ENV, m_henv), SQL_SUCCESS); return TRUE; } // Test the given GetInfo value TESTRESULT CKageraTest::TestGetInfo(enum GETINFO_ENUM eInfoValue) { return TEST_PASS; } //--------------------------------------------------------------------------- // CKageraTest::Init // // Init this test module //--------------------------------------------------------------------------- BOOL CKageraTest::Init() { m_cPropSets = 0; m_rgPropSets = NULL; // Setup the arrays needed for good init, based on string TMD passed to us TESTC(GetInitProps(&m_cPropSets, &m_rgPropSets)); return TRUE; CLEANUP: return FALSE; } //--------------------------------------------------------------------------- // CKageraTest::Terminate // // Terminate this test module //--------------------------------------------------------------------------- BOOL CKageraTest::Terminate() { // Clean up our variants we used in the init FreeProperties(&m_cPropSets,&m_rgPropSets); return CTestCases::Terminate(); } //-------------------------------------------------------------------- //@mfunc: Create a command object and set properties, execute a sql statement, // and create a rowset object. Create an accessor on the rowset // //-------------------------------------------------------------------- BOOL CKageraTest::GetRowsetAndAccessor ( EQUERY eSQLStmt, //the SQL Statement to create ULONG cProperties, //the count of properties const DBPROPID *rgProperties, //the array of properties to be set DBPROPSTATUS dwPropStatus, //rgProperties status ULONG cPropertiesUnset, //the count of properties to be unset const DBPROPID *rgPropertiesUnset, //the array of properties to be unset BOOL fBindLongColumn, //whether to bind LONG columns DBACCESSORFLAGS dwAccessorFlags, //the accessor flags DBPART dwPart, //the type of binding ECOLS_BOUND eColsToBind, //the columns in accessor ECOLUMNORDER eBindingOrder, //the order to bind columns ECOLS_BY_REF eColsByRef, //which columns to bind by reference DBTYPE dbTypeModifier, //the type modifier used for accessor DBORDINAL cColsToBind, //the count of columns to bind ULONG *rgColsToBind, //the array of column ordinals to bind ECOLS_MEM_PROV_OWNED eColsMemProvOwned, //@paramopt [IN] Which columns' memory is to be owned by the provider DBPARAMIO eParamIO //@paramopt [IN] Parameter type to specify for eParmIO ) { IColumnsInfo *pIColumnsInfo = NULL; IRowset *pIRowset = NULL; ULONG cRowsObtained = 0; HROW *pHRow = NULL; ULONG cDBPropSet = 1; DBPROPSET rgDBPropSet[2]; ULONG cProp = 0; HRESULT hr = S_OK; BOOL fPass = FALSE; BLOBTYPE blobType; ULONG ulIndex = 0; ULONG ulUpdValue = 0; ULONG ulMaxPendRows = 0; ULONG cExtraProps = 1; ULONG i = 0; m_pIAccessor = NULL; if(fBindLongColumn) blobType=BLOB_LONG; else blobType=NO_BLOB_COLS; //init DBPropSet[0] rgDBPropSet[0].rgProperties = NULL; rgDBPropSet[0].cProperties = 0; rgDBPropSet[0].guidPropertySet= DBPROPSET_ROWSET; //Set up the DB Properties struct if(cProperties || cPropertiesUnset) { //allocate rgDBPropSet[0].rgProperties=(DBPROP *)PROVIDER_ALLOC(sizeof(DBPROP) * (cProperties + cPropertiesUnset)); memset(rgDBPropSet[0].rgProperties,0,sizeof(DBPROP)*(cProperties + cPropertiesUnset)); if(!rgDBPropSet[0].rgProperties) { goto CLEANUP; } //Get Rowset interface so info from RowsetInfo can be obtainied // call IOpenRowset to return a Rowset hr = g_pTable->CreateRowset ( USE_OPENROWSET, IID_IRowset, 0, NULL, (IUnknown**)&pIRowset, NULL, NULL, NULL ); if (pIRowset) { //go through the loop to set every DB Property required for(i=0; iQueryInterface(IID_IRowset,(LPVOID *)&m_pIRowset),S_OK); // get the columns infomation TESTC_(m_pIAccessor->QueryInterface(IID_IColumnsInfo, (LPVOID *)&pIColumnsInfo),S_OK); TESTC_(pIColumnsInfo->GetColumnInfo(&m_cRowsetCols,&m_rgInfo, &m_pStringsBuffer),S_OK); //can not create an accessor on a rowset if no IRowset is present if(!m_pIRowset) { goto CLEANUP; } //create an accessor on the rowset hr = GetAccessorAndBindings(m_pIAccessor,dwAccessorFlags,&m_hAccessor, &m_rgBinding,&m_cBinding,&m_cRowSize,dwPart,eColsToBind,eBindingOrder, eColsByRef,NULL,NULL,NULL,dbTypeModifier,cColsToBind,(LONG_PTR *)rgColsToBind, NULL,eColsMemProvOwned,eParamIO,blobType); //allocate memory for the row m_pData=PROVIDER_ALLOC(m_cRowSize); if(!m_pData) { goto CLEANUP; } fPass=TRUE; CLEANUP: if(rgDBPropSet[0].rgProperties) PROVIDER_FREE(rgDBPropSet[0].rgProperties); SAFE_RELEASE(pIColumnsInfo); SAFE_RELEASE(pIRowset); if(m_pIRowset) { CHECK(m_pIRowset->ReleaseRows(cRowsObtained,pHRow,NULL,NULL,NULL),S_OK); PROVIDER_FREE(pHRow); //restart position. The rowset returns to its original state hr = m_pIRowset->RestartPosition(NULL); CHECK(hr==S_OK || hr==DB_S_COMMANDREEXECUTED, TRUE); } return fPass; } //-------------------------------------------------------------------- //@mfunc: release a rowset object and accessor created on it // //-------------------------------------------------------------------- void CKageraTest::ReleaseRowsetAndAccessor() { IAccessor *pIAccessor = NULL; //reset m_cRowset to 0 so that provider will allocate memory for next time m_cRowSize=0; m_cBinding=0; //free the consumer buffer PROVIDER_FREE(m_pData); //free accessor handle, if a rowset Accessor if(m_hAccessor && m_pIAccessor) { CHECK(m_pIAccessor->ReleaseAccessor(m_hAccessor,NULL), S_OK); m_hAccessor=NULL; } //free accessor handle, if a command Accessor if(m_hAccessor && m_pICommand) { //QI for the accessor handle on the command object if(CHECK(m_pICommand->QueryInterface(IID_IAccessor, (void**)&pIAccessor),S_OK)) { CHECK(pIAccessor->ReleaseAccessor(m_hAccessor,NULL), S_OK); } } //Release accessors SAFE_RELEASE(pIAccessor); SAFE_RELEASE(m_pIAccessor); m_hAccessor=NULL; //release IRowset pointer SAFE_RELEASE(m_pIRowset); //free binding structure PROVIDER_FREE(m_rgBinding); PROVIDER_FREE(m_rgInfo); PROVIDER_FREE(m_pStringsBuffer); ReleaseRowsetObject(0); ReleaseCommandObject(0); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // Test Case Section // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // {{ TCW_TEST_CASE_MAP(DBPROPSET_KAGPROP_GETINFO_Unititialized) //-------------------------------------------------------------------- // @class Test DBPROPSET_KAGPROP_GETINFO when unitialized // class DBPROPSET_KAGPROP_GETINFO_Unititialized : public CKageraTest { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(DBPROPSET_KAGPROP_GETINFO_Unititialized,CKageraTest); // }} // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember SQL_ACCESSIBLE_PROCEDURES int Variation_1(); // }} }; // {{ TCW_TESTCASE(DBPROPSET_KAGPROP_GETINFO_Unititialized) #define THE_CLASS DBPROPSET_KAGPROP_GETINFO_Unititialized BEG_TEST_CASE(DBPROPSET_KAGPROP_GETINFO_Unititialized, CKageraTest, L"Test DBPROPSET_KAGPROP_GETINFO when unitialized") TEST_VARIATION(1, L"SQL_ACCESSIBLE_PROCEDURES") END_TEST_CASE() #undef THE_CLASS // }} // }} // {{ TCW_TEST_CASE_MAP(DBPROPSET_KAGPROP_GETINFO_Initialized) //-------------------------------------------------------------------- // @class Test GetInfo property when initialized // class DBPROPSET_KAGPROP_GETINFO_Initialized : public CKageraTest { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(DBPROPSET_KAGPROP_GETINFO_Initialized,CKageraTest); // }} // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember SQL_ACCESSIBLE_PROCEDURES int Variation_1(); // }} }; // {{ TCW_TESTCASE(DBPROPSET_KAGPROP_GETINFO_Initialized) #define THE_CLASS DBPROPSET_KAGPROP_GETINFO_Initialized BEG_TEST_CASE(DBPROPSET_KAGPROP_GETINFO_Initialized, CKageraTest, L"Test GetInfo property when initialized") TEST_VARIATION(1, L"SQL_ACCESSIBLE_PROCEDURES") END_TEST_CASE() #undef THE_CLASS // }} // }} // {{ TCW_TEST_CASE_MAP(DriverErrors) //-------------------------------------------------------------------- // @class Test DriverErrors // class TCDriverErrors : public CKageraTest { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(TCDriverErrors,CKageraTest); // }} USHORT m_cHeader; USHORT m_cRecord; LCID m_lcid; IDBCreateCommand *m_pIDBCreateCommand; IDBCreateSession *m_pIDBCreateSession; ICommandText *m_pICommandText; ICommand *m_pICommand; IErrorInfo *m_pIErrorInfo; // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); BOOL RequestFieldsToCache ( IUnknown *pIUnknown, // @parm [IN] object to QI from for ISQLRequestDiagFields KAGREQDIAG rgReqDiag[], // @parm [IN] array of fields WORD cFieldCount // @parm [IN] number of fields in array ); BOOL GetODBCDiag ( KAGREQDIAG *rgReqDiag, // @parm [IN] array of name of diag fields to cache KAGGETDIAG *rgGetDiag, // @parm [OUT] array of info from fields requested HRESULT *rgGetDiagHR, // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error enum ERROR_HANDLE_ENUM eHandle, // @parm [IN] odbc handle error is requested on ULONG cArraySize // @parm [IN] number of fields in array ); BOOL OleGetDiagField ( KAGREQDIAG *rgReqDiag, // @parm [IN] array of name of fields to get KAGGETDIAG *rgGetDiag, // @parm [OUT] array of info from fields requested HRESULT *rgGetDiagHR, // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error ULONG cArraySize // @parm [IN] number of fields in array ); BOOL CauseErrorThroughODBC ( ERROR_HANDLE_ENUM eHandle // @parm [IN] odbc handle error should be requested on ); BOOL CauseErrorThroughOLEDB ( ERROR_HANDLE_ENUM eHandle, // @parm [IN] odbc handle error should be requested on ERROR_NUMBER eNum // @parm [IN] used to determine which error to cause ); BOOL CreateCommandObject(); BOOL FreeCommandObject(); // {{ TCW_TESTVARS() //@cmember HDBC Single Err - Request All, Get All int Variation_1(); //@cmember HDBC Single Err - Request None, Get All int Variation_2(); //@cmember HDBC Single Err - Request All (Header only), Get All int Variation_3(); //@cmember HDBC Single Err - Request All (Record only), Get All int Variation_4(); //@cmember HDBC Single Err - Request One Header where the diag indetifier // returns SQL_ERROR on the error, Get Header, // expect to see no diag custom error object // because no error was produced int Variation_5(); //@cmember HDBC Single Err - Request One Record where the diag indetifier // returns SQL_ERROR on the error, Get Record, // expect to see no diag custom error object // because no error was produced int Variation_6(); //@cmember HDBC Single Err - Request One Header where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header int Variation_7(); //@cmember HDBC Single Err - Request One Record where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one record int Variation_8(); //@cmember HDBC Multiple Err - Request All, Get All int Variation_9(); //@cmember HDBC Multiple (Stress) Err - Request All, Get All - Stress errors on HDBC int Variation_10(); //@cmember HDBC Single Err - Request All, Get All int Variation_11(); //@cmember HSTMT Single Err - Request None, Get All int Variation_12(); //@cmember HSTMT Single Err - Request All (Header only), Get All int Variation_13(); //@cmember HSTMT Single Err - Request All (Record only), Get All int Variation_14(); //@cmember HSTMT Single Err - Request One Header (all header fields // pass on a HSTMT), Get Header, // expect to see diag custom error object int Variation_15(); //@cmember HSTMT Single Err - Request One Record (all record fields // pass on a HSTMT), Get record, // expect to see diag custom error object // int Variation_16(); //@cmember HSTMT Single Err - Request One Header where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header int Variation_17(); //@cmember HSTMT Single Err - Request One Header where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one record int Variation_18(); //@cmember HSTMT Multiple Err - Request All, Get All int Variation_19(); //@cmember HSTMT Multiple (Stress) Err - Request All, Get All - Stress errors on HSTMT int Variation_20(); //@cmember Multiple Mixed Handle Err - Request All, Get All int Variation_21(); //@cmember INVALID ARG RequestDiagField int Variation_22(); //@cmember INVALID ARG GetDiagField int Variation_23(); // }} }; // {{ TCW_TESTCASE(TCDriverErrors) #define THE_CLASS TCDriverErrors BEG_TEST_CASE(TCDriverErrors, CKageraTest, L"Test Driver Errors") TEST_VARIATION(1, L"HDBC Single Err - Request All, Get All") TEST_VARIATION(2, L"HDBC Single Err - Request None, Get All") TEST_VARIATION(3, L"HDBC Single Err - Request All (Header only), Get All") TEST_VARIATION(4, L"HDBC Single Err - Request All (Record only), Get All") TEST_VARIATION(5, L"HDBC Single Err - Request One Header, indetifier returns SQL_ERROR on error") TEST_VARIATION(6, L"HDBC Single Err - Request One Record, indetifier returns SQL_ERROR on error") TEST_VARIATION(7, L"Request One Header where indetifier returns SQL_SUCCESS on error, Get more than one header") TEST_VARIATION(8, L"Request One Record where indetifier returns SQL_SUCCESS on error, Get more than one record") TEST_VARIATION(9, L"HDBC Multiple Err - Request All, Get All") TEST_VARIATION(10, L"HDBC Multiple (Stress) Err - Request All, Get All - Stress errors on HDBC") TEST_VARIATION(11, L"HSTMT Single Err - Request All, Get All") TEST_VARIATION(12, L"HSTMT Single Err - Request None, Get All") TEST_VARIATION(13, L"HSTMT Single Err - Request All (Header only), Get All") TEST_VARIATION(14, L"HSTMT Single Err - Request All (Record only), Get All") TEST_VARIATION(15, L"HSTMT Single Err - Request One Header") TEST_VARIATION(16, L"HSTMT Single Err - Request One Record") TEST_VARIATION(17, L"Request One Header where indetifier returns SQL_SUCCESS on error, Get more than one header") TEST_VARIATION(18, L"Request One Record where indetifier returns SQL_SUCCESS on error, Get more than one record") TEST_VARIATION(19, L"HDBC Multiple Err - Request All, Get All") TEST_VARIATION(20, L"HSTMT Multiple (Stress) Err - Request All, Get All - Stress errors on HDBC") TEST_VARIATION(21, L"Multiple Mixed Handle Err - Request All, Get All") TEST_VARIATION(22, L"INVALID ARG RequestDiagField") TEST_VARIATION(23, L"INVALID ARG GetDiagField") END_TEST_CASE() #undef THE_CLASS // }} // }} // }} END_DECLARE_TEST_CASES() // {{ TCW_TEST_CASE_MAP(TCKAGPROPS) //-------------------------------------------------------------------- // @class Test DBPROPSET_KAGPROP_GETINFO when unitialized // class TCKAGPROPS : public CKageraTest { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(TCKAGPROPS,CKageraTest); // }} // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember BLOBSONFOCURSOR OPTIONAL int Variation_1(); // @cmember BLOBSONFOCURSOR REQUIRED int Variation_2(); // }} }; // {{ TCW_TESTCASE(TCKAGPROPS) #define THE_CLASS TCKAGPROPS BEG_TEST_CASE(TCKAGPROPS, CKageraTest, L"Test different Kagera specific properties") TEST_VARIATION(1, L"BLOBSONFOCURSOR OPTIONAL") TEST_VARIATION(2, L"BLOBSONFOCURSOR REQUIRED") END_TEST_CASE() #undef THE_CLASS // }} // }} // {{ TCW_TEST_CASE_MAP(TCKAGADHOC) //-------------------------------------------------------------------- // @class Test adhoc // class TCKAGADHOC : public CKageraTest { private: // @cmember Static array of variations DECLARE_TEST_CASE_DATA(); public: // {{ TCW_DECLARE_FUNCS // @cmember Execution Routine DECLARE_TEST_CASE_FUNCS(TCKAGADHOC,CKageraTest); // }} // @cmember Initialization Routine virtual BOOL Init(); // @cmember Termination Routine virtual BOOL Terminate(); // {{ TCW_TESTVARS() // @cmember select from large row int Variation_1(); // }} }; // {{ TCW_TESTCASE(TCKAGPROPS) #define THE_CLASS TCKAGADHOC BEG_TEST_CASE(TCKAGADHOC, CKageraTest, L"Test bugs found through adhoc scenarios") TEST_VARIATION(1, L"select from large row") END_TEST_CASE() #undef THE_CLASS // }} // }} // {{ TCW_TESTMODULE(ThisModule) TEST_MODULE(5, ThisModule, gwszModuleDescrip) TEST_CASE(1, DBPROPSET_KAGPROP_GETINFO_Unititialized) TEST_CASE(2, DBPROPSET_KAGPROP_GETINFO_Initialized) TEST_CASE(3, TCDriverErrors) TEST_CASE(4, TCKAGPROPS) TEST_CASE(5, TCKAGADHOC) END_TEST_MODULE() // }} // {{ TCW_TC_PROTOTYPE(DBPROPSET_KAGPROP_GETINFO_Unititialized) //*----------------------------------------------------------------------- //| Test Case: DBPROPSET_KAGPROP_GETINFO_Unititialized - Test DBPROPSET_KAGPROP_GETINFO when unitialized //| Created: 03/29/97 //*----------------------------------------------------------------------- //-------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL DBPROPSET_KAGPROP_GETINFO_Unititialized::Init() { // {{ TCW_INIT_BASECLASS_CHECK return CKageraTest::Init(); // }} } // {{ TCW_VAR_PROTOTYPE(1) //*----------------------------------------------------------------------- // @mfunc SQL_ACCESSIBLE_PROCEDURES // // @rdesc TEST_PASS or TEST_FAIL // int DBPROPSET_KAGPROP_GETINFO_Unititialized::Variation_1() { return TRUE; //return TestGetInfo(E_ACCESSIBLE_PROCEDURES); } // }} // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL DBPROPSET_KAGPROP_GETINFO_Unititialized::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 return(CKageraTest::Terminate()); } // }} // }} // }} // {{ TCW_TC_PROTOTYPE(DBPROPSET_KAGPROP_GETINFO_Initialized) //*----------------------------------------------------------------------- //| Test Case: DBPROPSET_KAGPROP_GETINFO_Initialized - Test GetInfo property when initialized //| Created: 04/02/97 //*----------------------------------------------------------------------- //-------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL DBPROPSET_KAGPROP_GETINFO_Initialized::Init() { // {{ TCW_INIT_BASECLASS_CHECK return CKageraTest::Init(); // }} } // {{ TCW_VAR_PROTOTYPE(1) //-------------------------------------------------------------------- // @mfunc SQL_ACCESSIBLE_PROCEDURES // // @rdesc TEST_PASS or TEST_FAIL // int DBPROPSET_KAGPROP_GETINFO_Initialized::Variation_1() { return TEST_PASS; } // }} // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL DBPROPSET_KAGPROP_GETINFO_Initialized::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 return(CKageraTest::Terminate()); } // }} // }} // }} // {{ TCW_TC_PROTOTYPE(TCDriverErrors) //*----------------------------------------------------------------------- //| Test Case: TCDriverErrors - Test Driver Errors //| Created: 04/16/97 //*----------------------------------------------------------------------- //--------------------------------------------------------------------------- // TCDriverErrors::Init // // // TestCase Initialization Routine //--------------------------------------------------------------------------- BOOL TCDriverErrors::Init() { // {{ TCW_INIT_BASECLASS_CHECK if(CKageraTest::Init()) // }} { ULONG i = 0; m_lcid = GetSystemDefaultLCID(); m_cHeader=0; m_cRecord=0; //get the number of headers fields and the number of record fields (a field is one or the other) for (i=0;iQueryInterface(IID_ISQLRequestDiagFields,(void **)&pISQLRequestDiagFields),S_OK)) goto CLEANUP; //call request of DIAG constant if (FAILED(hr = pISQLRequestDiagFields->RequestDiagFields(cFieldCount,rgReqDiag))) { odtLog << L"Request To Set Error Field Failed.\n"; goto CLEANUP; } fResults = TRUE; CLEANUP: SAFE_RELEASE(pISQLRequestDiagFields) return fResults; } //--------------------------------------------------------------------------- // TCDriverErrors::OleGetDiagField // // @parm [IN] array of name of diag fields to cache // @parm [OUT] array of info from fields requested // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error // @parm [IN] odbc handle error is requested on // @parm [IN] number of fields in array // // this calls GetErrorInfo to GetDiagField to get info on the cusotm // error object reporitng on fields that have been cached //--------------------------------------------------------------------------- BOOL TCDriverErrors::OleGetDiagField ( KAGREQDIAG *rgReqDiag, // @parm [IN] array of name of fields to get KAGGETDIAG *rgGetDiag, // @parm [OUT] array of info from fields requested HRESULT *rgGetDiagHR, // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error ULONG cArraySize // @parm [IN] odbc handle error is requested on ) { BOOL fResults = FALSE; BOOL fFoundCustomErrorObject = FALSE; IErrorRecords *pIErrorRecords = NULL; ISQLErrorInfo *pISQLErrorInfo = NULL; IErrorInfo *pIErrorInfo = NULL; ISQLGetDiagField *pIGetDiagField = NULL; ISQLGetDiagField *pIGetDiagFieldHead = NULL; HRESULT hr; ULONG ulErrorRecCount = 0; ULONG i = 0; ULONG j = 0; WCHAR wszSQLSTATE[] = L"00000"; WCHAR* wszString = NULL ; BSTR pbstrDescription = NULL; LONG lNativeError; //Now get our current error object if (!CHECK(GetErrorInfo(0, &m_pIErrorInfo), S_OK)) { goto CLEANUP; } if (!m_pIErrorInfo) { goto CLEANUP; } //Get the IErrorRecord interface if (!CHECK(m_pIErrorInfo->QueryInterface(IID_IErrorRecords, (void **)&pIErrorRecords), S_OK)) { goto CLEANUP; } if (!pIErrorRecords) { goto CLEANUP; } //Find out how many records were created if (!CHECK(pIErrorRecords->GetRecordCount(&ulErrorRecCount), S_OK)) { goto CLEANUP; } //loop through error records and get first custom error object //not necessarily the 0 rec (bug 4193) for (i=0;iGetCustomErrorObject(i, IID_ISQLGetDiagField, (IUnknown**) &pIGetDiagField); if (hr==S_OK && pIGetDiagField) { //we got one break; } //if pIGetDiagField is NULL and valid hr then custom error object is empty //but there has to an error object somewhere, check to see that it is there if ((hr==S_OK&&!pIGetDiagField)||(hr==E_NOINTERFACE&&!pIGetDiagField)) { if (!CHECK(pIErrorRecords->GetCustomErrorObject(i, IID_ISQLErrorInfo, (IUnknown**) &pISQLErrorInfo), S_OK)||!pISQLErrorInfo) { if (!CHECK(pIErrorRecords->GetErrorInfo(i, m_lcid, (IErrorInfo**)&pIErrorInfo), S_OK)||!pIErrorInfo) { //if we are here there is not an error object //GetRecordCount said there was an error but there was none to get anywhere goto CLEANUP; } } //free if we just got an interface, we were just checking it was there SAFE_RELEASE(pISQLErrorInfo) SAFE_RELEASE(pIErrorInfo) SAFE_RELEASE(pIGetDiagField); continue; } else { goto CLEANUP; } } //no fields were requested if we are here and pIGetDiagField is NULL and hr is E_NOINTERFACE //so return TRUE, if this if evaluates to true and fields were requested there is a error, it will show later. if (!pIGetDiagField&&hr==E_NOINTERFACE) { fResults=TRUE; goto CLEANUP; } //check if this is a header record or a non-header record if (!CHECK(pIErrorRecords->GetCustomErrorObject(i, IID_ISQLErrorInfo, (IUnknown**) &pISQLErrorInfo), S_OK)) { goto CLEANUP; } if (!CHECK(pISQLErrorInfo->GetSQLInfo(&pbstrDescription,&lNativeError), S_OK)) { goto CLEANUP; } //if this custom error object is a header record then the SQLSTATE will be 00000 wszString = BSTR2WSTR(pbstrDescription); if(!wcscmp(wszSQLSTATE,wszString)) { if (pbstrDescription) { SysFreeString(pbstrDescription); pbstrDescription=NULL; PROVIDER_FREE(wszString); } SAFE_RELEASE(pISQLErrorInfo) //point to this interface with pIHead, and go get the record object pIGetDiagFieldHead=pIGetDiagField; pIGetDiagField=NULL; //since that was head the next custom errror object will be a record //check for record object (if there is one, there doens't have top be if only heads were cached) for (j=(i+1);jGetCustomErrorObject(j, IID_ISQLGetDiagField, (IUnknown**) &pIGetDiagField), S_OK) || !pIGetDiagField) { continue; } break; } } else { //if we are here we will have to use the following again so free'em if (pbstrDescription) { SysFreeString(pbstrDescription); pbstrDescription=NULL; PROVIDER_FREE(wszString); } SAFE_RELEASE(pISQLErrorInfo) //check for header object (if there is one) for (j=(i+1);jGetCustomErrorObject(j, IID_ISQLGetDiagField, (IUnknown**) &pIGetDiagFieldHead), S_OK) || !pIGetDiagFieldHead) { continue; } break; } //if there is an interface if (pIGetDiagFieldHead) { //check if this is a header object or a record object, (it has to be header) if (!CHECK(pIErrorRecords->GetCustomErrorObject(j, IID_ISQLErrorInfo, (IUnknown**) &pISQLErrorInfo), S_OK)) { goto CLEANUP; } if (!CHECK(pISQLErrorInfo->GetSQLInfo(&pbstrDescription,&lNativeError), S_OK)) { goto CLEANUP; } //if this custom error object is a header record then the SQLSTATE will be 00000 //if it is not a header object then drop it it is an illrelavent custom error object wszString = BSTR2WSTR(pbstrDescription); if(wcscmp(wszSQLSTATE,wszString)) { SAFE_RELEASE(pIGetDiagFieldHead) } if (pbstrDescription) { SysFreeString(pbstrDescription); pbstrDescription=NULL; PROVIDER_FREE(wszString); } SAFE_RELEASE(pISQLErrorInfo) } } //loop through the array of DIAG constants for (i=0;iGetDiagField(&rgGetDiag[i]))) { goto CLEANUP; } } else { //if test requested a record object then there has to be a record object if (!pIGetDiagField) { goto CLEANUP; } if (FAILED(rgGetDiagHR[i] = pIGetDiagField->GetDiagField(&rgGetDiag[i]))) { goto CLEANUP; } } } fResults = TRUE; CLEANUP: if (pbstrDescription) { SysFreeString(pbstrDescription); pbstrDescription=NULL; } SAFE_RELEASE(pIGetDiagField) SAFE_RELEASE(pIGetDiagFieldHead) SAFE_RELEASE(pISQLErrorInfo) SAFE_RELEASE(pIErrorInfo) SAFE_RELEASE(pIErrorRecords) SAFE_RELEASE(m_pIErrorInfo) return fResults; } //--------------------------------------------------------------------------- // TCDriverErrors::OleGetDiagField // // @parm [IN] array of name of diag fields to cache // @parm [OUT] array of info from fields requested // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error // @parm [IN] odbc handle error is requested on // @parm [IN] number of fields in array // // determine which handle the error is on loop through the KAGREQDIAG fields // fill them from direct calls to ODBC //--------------------------------------------------------------------------- BOOL TCDriverErrors::GetODBCDiag ( KAGREQDIAG *rgReqDiag, // @parm [IN] array of name of fields to get KAGGETDIAG *rgGetDiag, // @parm [OUT] array of info from fields requested HRESULT *rgGetDiagHR, // @parm [OUT] array corresponding to KAGGETDIAG saying if the field has any info for the error enum ERROR_HANDLE_ENUM eHandle, // @parm [IN] odbc handle error is requested on ULONG cArraySize // @parm [IN] number of fields in array ) { SQLLEN wDiagInfo = 0; TCHAR szDiagInfo[STRINGSIZE]; WCHAR wszDiagInfo[STRINGSIZE]; SQLSMALLINT wInfoOctetCount = 0; WORD cIndex = 0; BOOL fResults = FALSE; SQLRETURN rc; SHORT cRecNumber = 0; //loop through fields requested for (cIndex=0;cIndexSetProperties(m_cPropSets, m_rgPropSets))) { goto CLEANUP; } //bad Initialize (connect) hr = m_pIDBInitialize->Initialize(); // Make sure we didn't succeed if (hr == ResultFromScode(S_OK)) { CHECK(m_pIDBInitialize->Uninitialize(), S_OK); odtLog << L"ODBC error was not generated by OLEDB initialization, cannot continue with test case.\n"; //set to true because kagera can only generate one error on acess hdbc fResults=TRUE; goto CLEANUP; } switch (eNum) { case eERRORONE: //switch prop setting back so init won't cause OLEDB ERROR 1 (IM002) for (i=0;iSetCommandText(DBGUID_DBSQL,wszBadSQL))) { goto CLEANUP; } break; case eERRORTWO: if (!SUCCEEDED(hr = m_pICommandText->SetCommandText(DBGUID_DBSQL,wszBadSQL2))) { goto CLEANUP; } break; default: goto CLEANUP; } //this works cause pICommandText is a child of pICommand if (!FAILED(hr = m_pICommandText->Execute(NULL, IID_NULL, NULL, NULL, NULL))) { odtLog << L"ODBC error was not generated by OLEDB execute, cannot continue with test case.\n"; goto CLEANUP; } break; case eHDESC: break; default: break; } fResults=TRUE; CLEANUP: // Clean up our variants we used in the init return fResults; } //--------------------------------------------------------------------------- // TCDriverErrors::CreateCommandObject // // @mfunc // // gets a command object //--------------------------------------------------------------------------- BOOL TCDriverErrors::CreateCommandObject ( ) { BOOL fResults=FALSE; HRESULT hr; m_pIDBCreateSession = NULL; m_pIDBCreateCommand = NULL; m_pICommand = NULL; m_pICommandText = NULL; //GetCommandObject if (!SUCCEEDED(hr = m_pIDBInitialize->QueryInterface( IID_IDBCreateSession, (void**)&m_pIDBCreateSession))) { goto CLEANUP; } //start SESSION and while i'm there get a (COMMAND) CreateCommand interface if (!SUCCEEDED(hr = m_pIDBCreateSession->CreateSession( NULL, IID_IDBCreateCommand, (IUnknown **)&m_pIDBCreateCommand))) { goto CLEANUP; } if (!SUCCEEDED(hr = m_pIDBCreateCommand->CreateCommand( NULL, IID_ICommand, (IUnknown**)&m_pICommand))) { goto CLEANUP; } if (!SUCCEEDED(hr = m_pICommand->QueryInterface(IID_ICommandText, (void **)&m_pICommandText))) { goto CLEANUP; } fResults=TRUE; CLEANUP: return fResults; } //--------------------------------------------------------------------------- // TCDriverErrors::FreeCommandObject // // @mfunc // // frees a command object //--------------------------------------------------------------------------- BOOL TCDriverErrors::FreeCommandObject ( ) { SAFE_RELEASE(m_pICommandText) SAFE_RELEASE(m_pICommand) SAFE_RELEASE(m_pIDBCreateCommand) SAFE_RELEASE(m_pIDBCreateSession) return TRUE; } /////////////////////////////////////////////////////////////////////////////////////////////////////////// // {{ TCW_VAR_PROTOTYPE(1) //-------------------------------------------------------------------- // @mfunc HDBC Single Err - Request All, Get All // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_1() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; KAGGETDIAG rgGetDiagODBC[g_ccAllDiagFields]; HRESULT rgGetDiagHRODBC[g_ccAllDiagFields]; KAGGETDIAG rgGetDiagOLEDB[g_ccAllDiagFields]; HRESULT rgGetDiagHROLEDB[g_ccAllDiagFields]; ULONG i; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHDBC)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&g_rgKagDiagAll[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHDBC,g_ccAllDiagFields)) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,g_rgKagDiagAll,g_ccAllDiagFields)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],m_cHeader)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],m_cRecord)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=m_cHeader;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],1)) { goto CLEANUP; } //nothing to look at for (i=0;i<1;i++) { VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = TRUE; CLEANUP: SAFE_FREE(rgKagDiag) SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeState(STATE_UNINITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(6) //-------------------------------------------------------------------- // @mfunc HDBC Single Err - Request One Record where the diag indetifier // returns SQL_ERROR on the error, Get Record, // expect to see no diag custom error object // because no error was produced // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_6() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; KAGREQDIAG *rgKagDiag = (KAGREQDIAG*)PROVIDER_ALLOC(sizeof(KAGREQDIAG)*1); KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*1); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*1); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*1); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*1); ULONG i; ULONG j; //get a record field, the field doesn't apply to the error on the HDBC here for (i=0;i<1;i++) { j = i + (m_cHeader+1);//plus one at the end gets us to the first diag record field that fails on this hdbc rgKagDiag[i]=g_rgKagDiagAll[j]; } //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHDBC)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHDBC,1)) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],1)) { goto CLEANUP; } //nothing to compare for (i=0;i<1;i++) { VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = TRUE; CLEANUP: SAFE_FREE(rgKagDiag) SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeState(STATE_UNINITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(7) //-------------------------------------------------------------------- // @mfunc HDBC Single Err - Request One Header where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header rec // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_7() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; //the following fields are hard coded to be sure what fields were getting in case .h file is updated KAGREQDIAG rgKagDiag[]= { // field field flag field type KAGREQDIAGFLAGS_HEADER, VT_BSTR, SQL_DIAG_DYNAMIC_FUNCTION }; KAGREQDIAG rgKagDiag2[]= { // field field flag field type KAGREQDIAGFLAGS_HEADER, VT_I4, SQL_DIAG_CURSOR_ROW_COUNT, KAGREQDIAGFLAGS_HEADER, VT_BSTR, SQL_DIAG_DYNAMIC_FUNCTION }; KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); ULONG i; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHDBC)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag2[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHDBC,2)) { goto CLEANUP; } //this might ot might not pass depending on the odbc version, //if it does set it to false becuase it wasn't cached so it should fail oledb rgGetDiagHRODBC[0]=S_FALSE; rgGetDiagODBC[0].vDiagInfo.vt=0; //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag2[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],2)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;i<2;i++) { if (!COMPARE(rgGetDiagHROLEDB[i],rgGetDiagHRODBC[i])) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result handles.\n"; fTemp=FALSE; } if (!CompareVariant(&rgGetDiagOLEDB[i].vDiagInfo, &rgGetDiagODBC[i].vDiagInfo)) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result values.\n"; fTemp=FALSE; } VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = fTemp; CLEANUP: SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeState(STATE_UNINITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(8) //-------------------------------------------------------------------- // @mfunc HDBC Single Err - Request One Record where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header rec // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_8() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; //the following fields are hard coded to be sure what fields were getting in case .h file is updated KAGREQDIAG rgKagDiag[]= { // field field flag field type KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_CONNECTION_NAME }; KAGREQDIAG rgKagDiag2[]= { // field field flag field type KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_CONNECTION_NAME, KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_MESSAGE_TEXT }; KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); ULONG i; VARTYPE vTemp; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHDBC)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag2[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHDBC,2)) { goto CLEANUP; } //this field should pass, if it does set it to false becuase it wasn't cached so it should fail oledb if (rgGetDiagHRODBC[1]==S_OK) { rgGetDiagHRODBC[1] = S_FALSE; vTemp = rgGetDiagODBC[1].vDiagInfo.vt; rgGetDiagODBC[1].vDiagInfo.vt = 0; } //Request DIAG constant Field (single) To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics Fields (plural) if (!OleGetDiagField(&rgKagDiag2[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],2)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;i<2;i++) { if (!COMPARE(rgGetDiagHROLEDB[i],rgGetDiagHRODBC[i])) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result handles.\n"; fTemp=FALSE; } if (!CompareVariant(&rgGetDiagOLEDB[i].vDiagInfo, &rgGetDiagODBC[i].vDiagInfo)) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result values.\n"; fTemp=FALSE; } if (1==i) { rgGetDiagODBC[1].vDiagInfo.vt = vTemp; } VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = fTemp; CLEANUP: SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeState(STATE_UNINITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(9) //-------------------------------------------------------------------- // @mfunc HDBC Multiple Err - Request All, Get All // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_9() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; KAGGETDIAG rgGetDiagODBC[g_ccAllDiagFields]; HRESULT rgGetDiagHRODBC[g_ccAllDiagFields]; KAGGETDIAG rgGetDiagOLEDB[g_ccAllDiagFields]; HRESULT rgGetDiagHROLEDB[g_ccAllDiagFields]; ULONG i; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHDBC)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&g_rgKagDiagAll[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHDBC,g_ccAllDiagFields)) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,g_rgKagDiagAll,g_ccAllDiagFields)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORTWO)) { goto CLEANUP; } //Cause different error, this is the error that was caused in odbc above and the one we should see in oledb if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],m_cHeader)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],m_cRecord)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=m_cHeader;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],1)) { goto CLEANUP; } //nothing to look at for (i=0;i<1;i++) { VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = TRUE; CLEANUP: //free Command object SAFE_FREE(rgKagDiag) SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeCommandObject(); FreeState(STATE_INITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(16) //-------------------------------------------------------------------- // @mfunc HSTMT Single Err - Request One Record (all record fields // pass on a HSTMT), Get record, // expect to see diag custom error object // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_16() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; KAGREQDIAG *rgKagDiag = (KAGREQDIAG*)PROVIDER_ALLOC(sizeof(KAGREQDIAG)*1); KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*1); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*1); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*1); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*1); ULONG i; //get a record field, the field doesn't apply to the error on the HSTMT here for (i=0;i<1;i++) { rgKagDiag[i]=g_rgKagDiagAll[1]; } //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_INITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHSTMT)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHSTMT,1)) { goto CLEANUP; } //create Command object if (!CreateCommandObject()) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pICommand,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHSTMT,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pICommand->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],1)) { goto CLEANUP; } //nothing to compare for (i=0;i<1;i++) { VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = TRUE; CLEANUP: //free Command object SAFE_FREE(rgKagDiag) SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeCommandObject(); FreeState(STATE_INITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(17) //-------------------------------------------------------------------- // @mfunc HSTMT Single Err - Request One Header where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header rec // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_17() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; //the following fields are hard coded to be sure what fields were getting in case .h file is updated KAGREQDIAG rgKagDiag[]= { // field field flag field type KAGREQDIAGFLAGS_HEADER, VT_I4, SQL_DIAG_NUMBER }; KAGREQDIAG rgKagDiag2[]= { // field field flag field type KAGREQDIAGFLAGS_HEADER, VT_I4, SQL_DIAG_CURSOR_ROW_COUNT, KAGREQDIAGFLAGS_HEADER, VT_I4, SQL_DIAG_NUMBER }; KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); ULONG i; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_INITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHSTMT)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag2[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHSTMT,2)) { goto CLEANUP; } //this might ot might not pass depending on the odbc version, //if it does set it to false becuase it wasn't cached so it should fail oledb rgGetDiagHRODBC[0]=S_FALSE; rgGetDiagODBC[0].vDiagInfo.vt=0; //create Command object if (!CreateCommandObject()) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pICommand,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHSTMT,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pICommand->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&rgKagDiag2[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],2)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;i<2;i++) { if (!COMPARE(rgGetDiagHROLEDB[i],rgGetDiagHRODBC[i])) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result handles.\n"; fTemp=FALSE; } if (!CompareVariant(&rgGetDiagOLEDB[i].vDiagInfo, &rgGetDiagODBC[i].vDiagInfo)) { //the connectin name field will be different for each connected connection if (rgGetDiagOLEDB[i].sDiagField!=SQL_DIAG_CONNECTION_NAME) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result values.\n"; fTemp=FALSE; } } VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = fTemp; CLEANUP: //free Command object SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeCommandObject(); FreeState(STATE_INITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(18) //-------------------------------------------------------------------- // @mfunc HSTMT Single Err - Request One Record where the diag indetifier // returns SQL_SUCCESS on the error, Get more than one header rec // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_18() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; //the following fields are hard coded to be sure what fields were getting in case .h file is updated KAGREQDIAG rgKagDiag[]= { // field field flag field type KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_CONNECTION_NAME }; KAGREQDIAG rgKagDiag2[]= { // field field flag field type KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_CONNECTION_NAME, KAGREQDIAGFLAGS_RECORD, VT_BSTR, SQL_DIAG_MESSAGE_TEXT }; KAGGETDIAG *rgGetDiagODBC = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHRODBC = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); KAGGETDIAG *rgGetDiagOLEDB = (KAGGETDIAG*)PROVIDER_ALLOC(sizeof(KAGGETDIAG)*2); HRESULT *rgGetDiagHROLEDB = (HRESULT*)PROVIDER_ALLOC(sizeof(HRESULT)*2); ULONG i; VARTYPE vTemp; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_INITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHSTMT)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&rgKagDiag2[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHSTMT,2)) { goto CLEANUP; } //this field should pass, if it does set it to false becuase it wasn't cached so it should fail oledb if (COMPARE(rgGetDiagHRODBC[1],S_OK)) { rgGetDiagHRODBC[1] = S_FALSE; vTemp = rgGetDiagODBC[1].vDiagInfo.vt; rgGetDiagODBC[1].vDiagInfo.vt = 0; } //create Command object if (!CreateCommandObject()) { goto CLEANUP; } //Request DIAG constant Field (single) To Cache in custom error object if (!RequestFieldsToCache(m_pICommand,&rgKagDiag[0],1)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHSTMT,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pICommand->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics Fields (plural) if (!OleGetDiagField(&rgKagDiag2[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],2)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics for (i=0;i<2;i++) { if (!COMPARE(rgGetDiagHROLEDB[i],rgGetDiagHRODBC[i])) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result handles.\n"; fTemp=FALSE; } if (!CompareVariant(&rgGetDiagOLEDB[i].vDiagInfo, &rgGetDiagODBC[i].vDiagInfo)) { //the connectin name field will be different for each connected connection if (rgGetDiagOLEDB[i].sDiagField!=SQL_DIAG_CONNECTION_NAME) { odtLog << L"Mismatch in OLEDB vs ODBC Diagnostics result values.\n"; fTemp=FALSE; } } if (1==i) { rgGetDiagODBC[1].vDiagInfo.vt = vTemp; } VariantClear(&rgGetDiagOLEDB[i].vDiagInfo); VariantClear(&rgGetDiagODBC[i].vDiagInfo); } fResult = fTemp; CLEANUP: //free Command object SAFE_FREE(rgGetDiagODBC) SAFE_FREE(rgGetDiagHRODBC) SAFE_FREE(rgGetDiagOLEDB) SAFE_FREE(rgGetDiagHROLEDB) SAFE_RELEASE(pISupportErrorInfo) FreeCommandObject(); FreeState(STATE_INITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(19) //-------------------------------------------------------------------- // @mfunc HSTMT Multiple Err - Request All, Get All // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_19() { BOOL fResult = FALSE; BOOL fTemp = TRUE; ISupportErrorInfo *pISupportErrorInfo = NULL; DWORD cIndex = 0; KAGGETDIAG rgGetDiagODBC[g_ccAllDiagFields]; HRESULT rgGetDiagHRODBC[g_ccAllDiagFields]; KAGGETDIAG rgGetDiagOLEDB[g_ccAllDiagFields]; HRESULT rgGetDiagHROLEDB[g_ccAllDiagFields]; ULONG i; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_INITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Cause ODBC error on connection handle through ODBC if (!CauseErrorThroughODBC(eHSTMT)) { goto CLEANUP; } //Get ODBC diagnotics put into array of KAGGETDIAG just like call to GetDiagField would if (!GetODBCDiag(&g_rgKagDiagAll[0], &rgGetDiagODBC[0], &rgGetDiagHRODBC[0], eHSTMT,g_ccAllDiagFields)) { goto CLEANUP; } //create Command object if (!CreateCommandObject()) { goto CLEANUP; } //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pICommand,g_rgKagDiagAll,g_ccAllDiagFields)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHSTMT,eERRORTWO)) { goto CLEANUP; } //Cause error that was cause in odbc above, this is the latest one so we should see it in oledb if (!CauseErrorThroughOLEDB(eHSTMT,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pICommand->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_ICommand), S_OK)) { goto CLEANUP; } //Get OLE DB diagnostics if (!OleGetDiagField(&g_rgKagDiagAll[0], &rgGetDiagOLEDB[0], &rgGetDiagHROLEDB[0],g_ccAllDiagFields)) { goto CLEANUP; } //Compare OLE DB diagnostics with ODBC diagnostics S_OK for (i=0;iQueryInterface(IID_ISQLRequestDiagFields,(void **)&pISQLRequestDiagFields),S_OK)) { goto CLEANUP; } SAFE_RELEASE(pISQLRequestDiagFields) //call request with NULL, expect invalid arg if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISQLRequestDiagFields,(void **)&pISQLRequestDiagFields),S_OK)) { goto CLEANUP; } //rgDiagFields should not be NULL unless cDiagFields is zero if (!CHECK(pISQLRequestDiagFields->RequestDiagFields(1,NULL),E_INVALIDARG)) { odtLog << L"RequestDiagFields Not Checking for INVALID ARG.\n"; goto CLEANUP; } fResult=TRUE; CLEANUP: SAFE_RELEASE(pISQLRequestDiagFields) //free Command object FreeState(STATE_INITIALIZED_DSO); return fResult; } // }} // {{ TCW_VAR_PROTOTYPE(23) //-------------------------------------------------------------------- // @mfunc INVALID ARG GetDiagField, test has to do lots to get // CustomErrorObject so it can get to GetDiagField method just to test INVALID_ARG // // @rdesc TEST_PASS or TEST_FAIL // int TCDriverErrors::Variation_23() { BOOL fResults = FALSE; IErrorRecords *pIErrorRecords = NULL; ISQLErrorInfo *pISQLErrorInfo = NULL; IErrorInfo *pIErrorInfo = NULL; ISupportErrorInfo *pISupportErrorInfo = NULL; ISQLGetDiagField *pIGetDiagField = NULL; HRESULT hr; ULONG ulErrorRecCount = 0; ULONG i = 0; //Get to ODBC to proper state and OLE DB to proper state GetMeToState(STATE_UNINITIALIZED_DSO,(SQLPOINTER)SQL_OV_ODBC2); //Request DIAG constant Fields To Cache in custom error object if (!RequestFieldsToCache(m_pIDBInitialize,g_rgKagDiagAll,g_ccAllDiagFields)) { goto CLEANUP; } //Cause ODBC error on connection handle through OLEDB if (!CauseErrorThroughOLEDB(eHDBC,eERRORONE)) { goto CLEANUP; } //Check that current interface supports error objects if (!CHECK(m_pIDBInitialize->QueryInterface(IID_ISupportErrorInfo, (void **)&pISupportErrorInfo), S_OK)) { goto CLEANUP; } if (!pISupportErrorInfo) { goto CLEANUP; } if (!CHECK(pISupportErrorInfo->InterfaceSupportsErrorInfo(IID_IDBInitialize), S_OK)) { goto CLEANUP; } //Now get our current error object if (!CHECK(GetErrorInfo(0, &m_pIErrorInfo), S_OK)) { goto CLEANUP; } if (!m_pIErrorInfo) { goto CLEANUP; } //Get the IErrorRecord interface if (!CHECK(m_pIErrorInfo->QueryInterface(IID_IErrorRecords, (void **)&pIErrorRecords), S_OK)) { goto CLEANUP; } if (!pIErrorRecords) { goto CLEANUP; } //Find out how many records were created if (!CHECK(pIErrorRecords->GetRecordCount(&ulErrorRecCount), S_OK)) { goto CLEANUP; } //loop through error records and get first custom error object //not necessarily the 0 rec (bug 4193) for (i=0;iGetCustomErrorObject(i, IID_ISQLGetDiagField, (IUnknown**) &pIGetDiagField); if (hr==S_OK && pIGetDiagField) { //we got one break; } //if pIGetDiagField is NULL and valid hr then custom error object is empty //but there has to an error object somewhere, check to see that it is there if ((hr==S_OK&&!pIGetDiagField)||(hr==E_NOINTERFACE&&!pIGetDiagField)) { if (!CHECK(pIErrorRecords->GetCustomErrorObject(i, IID_ISQLErrorInfo, (IUnknown**) &pISQLErrorInfo), S_OK)||!pISQLErrorInfo) { if (!CHECK(pIErrorRecords->GetErrorInfo(i, m_lcid, (IErrorInfo**)&pIErrorInfo), S_OK)||!pIErrorInfo) { //if we are here there is not an error object //GetRecordCount said there was an error but there was none to get anywhere goto CLEANUP; } } //free if we just got an interface, we were just checking it was there SAFE_RELEASE(pISQLErrorInfo) SAFE_RELEASE(pIErrorInfo) continue; } else { goto CLEANUP; } } //no fields were requested if we are here and pIGetDiagField is NULL and hr ius E_NOINTERFACE //so return TRUE if (!pIGetDiagField&&hr==E_NOINTERFACE) { fResults=TRUE; goto CLEANUP; } //if test requested a record object then there has to be a record object if (!pIGetDiagField) { goto CLEANUP; } //**CHECK for INVALID arg if (!CHECK(pIGetDiagField->GetDiagField(NULL),E_INVALIDARG)) { odtLog << L"GetDiagField Not Checking for INVALID ARG.\n"; goto CLEANUP; } fResults=TRUE; CLEANUP: FreeState(STATE_UNINITIALIZED_DSO); SAFE_RELEASE(m_pIErrorInfo) SAFE_RELEASE(pIGetDiagField); SAFE_RELEASE(pISQLErrorInfo); SAFE_RELEASE(pIErrorInfo); SAFE_RELEASE(pIErrorRecords); SAFE_RELEASE(pISupportErrorInfo); return fResults; } // }} // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL TCDriverErrors::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 return(CKageraTest::Terminate()); } // }} // }} // }} // {{ TCW_TC_PROTOTYPE(TCKAGPROPS) //*----------------------------------------------------------------------- //| Test Case: TCKAGPROPS - Test Kagera specific properties //| Created: 01/29/99 //*----------------------------------------------------------------------- //-------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL TCKAGPROPS::Init() { // {{ TCW_INIT_BASECLASS_CHECK //Init baseclass CRowsetObject::Init(); //Use the global DSO created in Module init SetDataSourceObject(g_pIDBInitialize); //Use the global DB Rowset created in Module init SetDBSession(g_pIOpenRowset); //Use the global CTable created in Module init, by default SetTable(g_pTable, DELETETABLE_NO); //Use the global C1RowTable for the second table, if ever needed SetTable2(g_p1RowTable, DELETETABLE_NO); m_ulTableRows = g_pTable->CountRowsOnTable(); g_pTable->DoesIndexExist(&m_bIndexExists); return CKageraTest::Init(); // }} } // } // {{ TCW_VAR_PROTOTYPE(1) //*----------------------------------------------------------------------- // @mfunc BLOBSONFOCURSOR OPTIONAL // // @rdesc TEST_PASS or TEST_FAIL // int TCKAGPROPS::Variation_1() { DBPROPID rgPropertyIDs[1]; BOOL fTestPass = TEST_FAIL; //initialization rgPropertyIDs[0]=KAGPROP_BLOBSONFOCURSOR; //get a rowset and accessor TESTC_PROVIDER(GetRowsetAndAccessor(SELECT_ORDERBYNUMERIC,1,rgPropertyIDs,DBPROPOPTIONS_OPTIONAL, 0,NULL,FALSE, DBACCESSOR_ROWDATA,DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH, UPDATEABLE_COLS_BOUND)); fTestPass=TEST_PASS; CLEANUP: ReleaseRowsetAndAccessor(); return fTestPass; } // }} // {{ TCW_VAR_PROTOTYPE(2) //*----------------------------------------------------------------------- // @mfunc BLOBSONFOCURSOR REQUIRED // // @rdesc TEST_PASS or TEST_FAIL // int TCKAGPROPS::Variation_2() { DBPROPID rgPropertyIDs[1]; BOOL fTestPass = TEST_FAIL; //initialization rgPropertyIDs[0]=KAGPROP_BLOBSONFOCURSOR; //get a rowset and accessor TESTC_PROVIDER(GetRowsetAndAccessor(SELECT_ORDERBYNUMERIC,1,rgPropertyIDs,DBPROPOPTIONS_REQUIRED, 0,NULL,FALSE, DBACCESSOR_ROWDATA,DBPART_VALUE|DBPART_STATUS|DBPART_LENGTH, UPDATEABLE_COLS_BOUND)); fTestPass=TEST_PASS; CLEANUP: ReleaseRowsetAndAccessor(); return fTestPass; } // }} // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL TCKAGPROPS::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 ReleaseRowsetObject(); //releases m_pIAccessor ReleaseCommandObject(); //releases m_pICommand ReleaseDBSession(); ReleaseDataSourceObject(); CRowsetObject::Terminate(); return(CKageraTest::Terminate()); } // }} // }} // }} // {{ TCW_TC_PROTOTYPE(TCKAGADHOC) //*----------------------------------------------------------------------- //| Test Case: TCKAGADHOC - Test Kagera adhoc scenarios //| Created: 05/19/00 //*----------------------------------------------------------------------- //-------------------------------------------------------------------- // @mfunc TestCase Initialization Routine // // @rdesc TRUE or FALSE // BOOL TCKAGADHOC::Init() { if (g_fSqlServer) { // {{ TCW_INIT_BASECLASS_CHECK //Init baseclass CRowsetObject::Init(); //Use the global DSO created in Module init SetDataSourceObject(g_pIDBInitialize); //Use the global DB Rowset created in Module init SetDBSession(g_pIOpenRowset); return CKageraTest::Init(); } else { if (!CKageraTest::Init()) return TEST_FAIL; return TEST_SKIPPED; } // }} } // } // {{ TCW_VAR_PROTOTYPE(1) //*----------------------------------------------------------------------- // @mfunc select from table with large row // // @rdesc TEST_PASS or TEST_FAIL // int TCKAGADHOC::Variation_1() { BOOL fTestPass = TEST_FAIL; IDBCreateCommand *pIDBCreateCommand = NULL; ICommandProperties *pICommandProperties= NULL; ICommand *pICommand = NULL; ICommandText *pICommandText = NULL; IRowset *pIRowset = NULL; DBROWCOUNT cRows = 0; DBCOUNTITEM cRowsOut = 0; HROW *phrow = NULL; DBPROPSET dbPropSet[1]; DBPROP dbProp[2]; //QI for the accessor handle on the command object CHECK(g_pIOpenRowset->QueryInterface(IID_IDBCreateCommand, (void**)&pIDBCreateCommand),S_OK); CHECK(pIDBCreateCommand->CreateCommand(NULL,IID_ICommand,(IUnknown**)&pICommand),S_OK); CHECK(pICommand->QueryInterface(IID_ICommandText, (void**)&pICommandText),S_OK); CHECK(pICommand->QueryInterface(IID_ICommandProperties, (void**)&pICommandProperties),S_OK); dbProp[0].dwPropertyID = DBPROP_OTHERUPDATEDELETE; dbProp[0].dwOptions = DBPROPOPTIONS_REQUIRED; dbProp[0].dwStatus = DBPROPSTATUS_OK; dbProp[0].colid = DB_NULLID; dbProp[0].vValue.vt = VT_BOOL; V_BOOL(&dbProp[0].vValue) = VARIANT_FALSE; dbProp[1].dwPropertyID = DBPROP_CANHOLDROWS; dbProp[1].dwOptions = DBPROPOPTIONS_REQUIRED; dbProp[1].dwStatus = DBPROPSTATUS_OK; dbProp[1].colid = DB_NULLID; dbProp[1].vValue.vt = VT_BOOL; V_BOOL(&dbProp[1].vValue) = VARIANT_TRUE; dbPropSet[0].guidPropertySet = DBPROPSET_ROWSET; dbPropSet[0].cProperties = 2; dbPropSet[0].rgProperties = dbProp; CHECK(pICommandProperties->SetProperties(1,dbPropSet),S_OK); CHECK(pICommandText->SetCommandText(DBGUID_DEFAULT, L"Drop table XLongFieldsX"), S_OK); pICommand->Execute(NULL, IID_IRowset, NULL, &cRows, (IUnknown**)&pIRowset); CHECK(pICommandText->SetCommandText(DBGUID_DEFAULT, L"CREATE TABLE XLongFieldsX ([key] [int] IDENTITY (1, 1) NOT NULL , [1] [varchar] (7000) NULL , [2] [varchar] (7000) NULL , [3] [varchar] (7000) NULL ,[4] [varchar] (7000) NULL , [5] [varchar] (7000) NULL , [6] [varchar] (7000) NULL ,[7] [varchar] (7000) NULL , [8] [varchar] (7000) NULL , [9] [varchar] (7000) NULL ,[10] [varchar] (7000) NULL , [11] [varchar] (7000) NULL , [12] [varchar] (7000) NULL ,[13] [varchar] (7000) NULL , [14] [varchar] (7000) NULL , [15] [varchar] (7000) NULL ,[16] [varchar] (7000) NULL , [17] [varchar] (7000) NULL , [18] [varchar] (7000) NULL ,[19] [varchar] (7000) NULL , [20] [varchar] (7000) NULL)"), S_OK); CHECK(pICommand->Execute(NULL, IID_IRowset, NULL, &cRows, (IUnknown**)&pIRowset), S_OK); CHECK(pICommandText->SetCommandText(DBGUID_DEFAULT, L"Insert into XLongFieldsX values ('abc', 'abc', 'abc', 'abc', 'abc','abc', 'abc', 'abc', 'abc', 'abc','abc', 'abc', 'abc', 'abc', 'abc','abc', 'abc', 'abc', 'abc', 'abc')"), S_OK); CHECK(pICommand->Execute(NULL, IID_IRowset, NULL, &cRows, (IUnknown**)&pIRowset), S_OK); CHECK(pICommandText->SetCommandText(DBGUID_DEFAULT, L"Insert into XLongFieldsX values ('xyz', 'xyz', 'xyz', 'xyz', 'xyz','xyz', 'xyz', 'xyz', 'xyz', 'xyz','xyz', 'xyz', 'xyz', 'xyz', 'xyz','xyz', 'xyz', 'xyz', 'xyz', 'xyz')"), S_OK); CHECK(pICommand->Execute(NULL, IID_IRowset, NULL, &cRows, (IUnknown**)&pIRowset), S_OK); CHECK(pICommandText->SetCommandText(DBGUID_DEFAULT, L"select * from XLongFieldsX"), S_OK); CHECK(pICommand->Execute(NULL, IID_IRowset, NULL, NULL, (IUnknown**)&pIRowset), S_OK); CHECK(pIRowset->GetNextRows(NULL,0,1,&cRowsOut,&phrow), S_OK); fTestPass=TEST_PASS; SAFE_RELEASE(pICommandProperties); SAFE_RELEASE(pIRowset); SAFE_RELEASE(pIRowset); SAFE_RELEASE(pICommand); SAFE_RELEASE(pICommandText); SAFE_RELEASE(pIDBCreateCommand); return fTestPass; } // }} // {{ TCW_TERMINATE_METHOD //-------------------------------------------------------------------- // @mfunc TestCase Termination Routine // // @rdesc TRUE or FALSE // BOOL TCKAGADHOC::Terminate() { // {{ TCW_TERM_BASECLASS_CHECK2 ReleaseDBSession(); ReleaseDataSourceObject(); CRowsetObject::Terminate(); return(CKageraTest::Terminate()); } // }} // }} // }}