2149 lines
55 KiB
C++
2149 lines
55 KiB
C++
//--------------------------------------------------------------------
|
|
// Microsoft OLE DB Test
|
|
//
|
|
// Copyright 1995-2000 Microsoft Corporation.
|
|
//
|
|
// @doc
|
|
//
|
|
// @module IDBCRCMD.CPP | This is the IDBCreateCommand.
|
|
//
|
|
|
|
#include "modstandard.hpp" // Standard headers, precompiled in modcore.cpp
|
|
#include "idbcrcmd.h" // Testcase's header
|
|
#include "ExtraLib.h"
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// Module Values
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// {{ TCW_MODULE_GLOBALS
|
|
DECLARE_MODULE_CLSID = { 0x9f079350, 0xd81c, 0x11ce, { 0x98, 0x81, 0x00, 0xaa, 0x00, 0x37, 0xda, 0x9b }};
|
|
DECLARE_MODULE_NAME("IDBCreateCommand");
|
|
DECLARE_MODULE_OWNER("Microsoft");
|
|
DECLARE_MODULE_DESCRIP("Test module for IDBCreateCommand Interface.");
|
|
DECLARE_MODULE_VERSION(832461938);
|
|
// TCW_WizardVersion(2)
|
|
// TCW_Automation(True)
|
|
// }} TCW_MODULE_GLOBALS_END
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Module level initialization routine
|
|
//
|
|
// @rdesc Success or Failure
|
|
// @flag TRUE | Successful initialization
|
|
// @flag FALSE | Initialization problems
|
|
//
|
|
BOOL ModuleInit(CThisTestModule * pThisTestModule)
|
|
{
|
|
IDBCreateSession* pIDBCreateSession = NULL;
|
|
IDBCreateCommand* pIDBCreateCommand = NULL;
|
|
BOOL bValue = FALSE;
|
|
|
|
TESTC(CommonModuleInit(pThisTestModule));
|
|
|
|
// IDBCreateSession
|
|
TESTC(VerifyInterface(pThisTestModule->m_pIUnknown, IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&pIDBCreateSession));
|
|
|
|
// IDBCreateCommand
|
|
if(!VerifyInterface(pThisTestModule->m_pIUnknown2, IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand))
|
|
{
|
|
odtLog << L"Commands are not supported by this Provider." << ENDL;
|
|
bValue = TEST_SKIPPED;
|
|
goto CLEANUP;
|
|
}
|
|
|
|
bValue = TRUE;
|
|
|
|
CLEANUP:
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(pIDBCreateSession);
|
|
SAFE_RELEASE(pIDBCreateCommand);
|
|
return bValue;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Module level termination routine
|
|
//
|
|
// @rdesc Success or Failure
|
|
// @flag TRUE | Successful initialization
|
|
// @flag FALSE | Initialization problems
|
|
//
|
|
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
|
|
{
|
|
return CommonModuleTerminate(pThisTestModule);
|
|
}
|
|
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// Base Class Section
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// @class TCIDBCRCMD Base Class for IDBCreateCommand:CreateCommand Testcases
|
|
class TCIDBCRCMD : public CRowset
|
|
{
|
|
public:
|
|
// @cmember Constructor
|
|
TCIDBCRCMD(LPWSTR wstrTestCaseName) : CRowset(wstrTestCaseName)
|
|
{
|
|
m_pIDBCreateSession = NULL;
|
|
m_pIDBCreateCommand = NULL;
|
|
};
|
|
|
|
// @cmember Destructor
|
|
virtual ~TCIDBCRCMD(){};
|
|
|
|
BOOL InitializeRowObject();
|
|
|
|
protected:
|
|
// @cmember IDBCreateSession Interface
|
|
IDBCreateSession* m_pIDBCreateSession;
|
|
// @cmember IDBCreateCommand Interface
|
|
IDBCreateCommand* m_pIDBCreateCommand;
|
|
// @cmember CRowObject pointer
|
|
CRowObject* m_pCRowObject;
|
|
// @cmember Row handle
|
|
HROW m_hRow;
|
|
};
|
|
|
|
|
|
// @class TCZOMBIE Base Class for IDBCreateCommand:ZombieCommand Testcases
|
|
class TCZOMBIE : public CTransaction
|
|
{
|
|
public:
|
|
// @cmember Constructor
|
|
TCZOMBIE(LPWSTR wstrTestCaseName) : CTransaction(wstrTestCaseName)
|
|
{
|
|
m_fRowCommand = FALSE;
|
|
};
|
|
|
|
// @cmember Destructor
|
|
virtual ~TCZOMBIE(){};
|
|
|
|
protected:
|
|
// @cmember flag to indicate source of IDBCreateCommand
|
|
BOOL m_fRowCommand;
|
|
};
|
|
|
|
|
|
// @class TCMULTICMD Base Class for IDBCreateCommand:MultipleObject Testcases
|
|
class TCMULTICMD : public TCIDBCRCMD
|
|
{
|
|
public:
|
|
// @cmember Constructor
|
|
TCMULTICMD(LPWSTR wstrTestCaseName) : TCIDBCRCMD(wstrTestCaseName)
|
|
{
|
|
m_pIDBCreateSession = NULL;
|
|
m_pIDBCreateCommand = NULL;
|
|
};
|
|
|
|
// @cmember Destructor
|
|
virtual ~TCMULTICMD(){};
|
|
|
|
// @cmember Tests QI on IUnknown from the ICommand Pointer
|
|
int TestInterface(IID iid, BOOL mandatory);
|
|
};
|
|
|
|
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
// Test Case Section
|
|
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCIDBCRCMD_CreateCommand)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CreateCommand
|
|
//
|
|
class TCIDBCRCMD_CreateCommand : public TCIDBCRCMD {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
~TCIDBCRCMD_CreateCommand (void) {};
|
|
TCIDBCRCMD_CreateCommand ( wchar_t* pwszTestCaseName) : TCIDBCRCMD(pwszTestCaseName) { };
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// {{ TCW_TESTVARS()
|
|
// @cmember E_NOINTERFACE - Invalid REFIID
|
|
int Variation_1();
|
|
// @cmember E_NOINTERFACE - IID_IDBInitialize REFIID
|
|
int Variation_2();
|
|
// @cmember E_NOINTERFACE - IID_IDBCreateCommand REFIID
|
|
int Variation_3();
|
|
// @cmember E_INVALIDARG - NULL pCommand
|
|
int Variation_4();
|
|
// @cmember S_OK - IID_ICommand for REFIID
|
|
int Variation_5();
|
|
// @cmember S_OK - IID_ICommandText for REFIID
|
|
int Variation_6();
|
|
// @cmember S_OK - IID_IColumnsInfo for REFIID
|
|
int Variation_7();
|
|
// }} TCW_TESTVARS_END
|
|
};
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCIDBCRCMD_CreateCommand_FromSession)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CreateCommand
|
|
//
|
|
class TCIDBCRCMD_CreateCommand_FromSession : public TCIDBCRCMD_CreateCommand {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCIDBCRCMD_CreateCommand_FromSession,TCIDBCRCMD_CreateCommand);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCIDBCRCMD_CreateCommand_FromSession)
|
|
#define THE_CLASS TCIDBCRCMD_CreateCommand_FromSession
|
|
BEG_TEST_CASE(TCIDBCRCMD_CreateCommand_FromSession, TCIDBCRCMD_CreateCommand, L"IDBCreateCommand::CreateCommand")
|
|
TEST_VARIATION(1, L"E_NOINTERFACE - Invalid REFIID")
|
|
TEST_VARIATION(2, L"E_NOINTERFACE - IID_IDBInitialize REFIID")
|
|
TEST_VARIATION(3, L"E_NOINTERFACE - IID_IDBCreateCommand REFIID")
|
|
TEST_VARIATION(4, L"E_INVALIDARG - NULL pCommand")
|
|
TEST_VARIATION(5, L"S_OK - IID_ICommand for REFIID")
|
|
TEST_VARIATION(6, L"S_OK - IID_ICommandText for REFIID")
|
|
TEST_VARIATION(7, L"S_OK - IID_IColumnsInfo for REFIID")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCIDBCRCMD_CreateCommand_FromRow)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CreateCommand
|
|
//
|
|
class TCIDBCRCMD_CreateCommand_FromRow : public TCIDBCRCMD_CreateCommand {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCIDBCRCMD_CreateCommand_FromRow,TCIDBCRCMD_CreateCommand);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCIDBCRCMD_CreateCommand_FromRow)
|
|
#define THE_CLASS TCIDBCRCMD_CreateCommand_FromRow
|
|
BEG_TEST_CASE(TCIDBCRCMD_CreateCommand_FromRow, TCIDBCRCMD, L"IDBCreateCommand::CreateCommand")
|
|
TEST_VARIATION(1, L"E_NOINTERFACE - Invalid REFIID")
|
|
TEST_VARIATION(2, L"E_NOINTERFACE - IID_IDBInitialize REFIID")
|
|
TEST_VARIATION(3, L"E_NOINTERFACE - IID_IDBCreateCommand REFIID")
|
|
TEST_VARIATION(4, L"E_INVALIDARG - NULL pCommand")
|
|
TEST_VARIATION(5, L"S_OK - IID_ICommand for REFIID")
|
|
TEST_VARIATION(6, L"S_OK - IID_ICommandText for REFIID")
|
|
TEST_VARIATION(7, L"S_OK - IID_IColumnsInfo for REFIID")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::MultipleObjects
|
|
//
|
|
class TCMULTICMD_QueryInterface : public TCMULTICMD {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
~TCMULTICMD_QueryInterface(void) {} ;
|
|
TCMULTICMD_QueryInterface( wchar_t* pwszTestCaseName) : TCMULTICMD(pwszTestCaseName) { };
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// @cmember S_OK - ICommand
|
|
int Variation_1();
|
|
// @cmember S_OK - ICommandText
|
|
int Variation_2();
|
|
// @cmember S_OK - ICommandWithParameters
|
|
int Variation_3();
|
|
// @cmember S_OK - ICommandPrepare
|
|
int Variation_4();
|
|
// @cmember S_OK - ICommandProperties
|
|
int Variation_5();
|
|
// @cmember S_OK - IColumnsInfo
|
|
int Variation_6();
|
|
// @cmember S_OK - IColumnsRowset
|
|
int Variation_7();
|
|
// @cmember S_OK - IAccessor
|
|
int Variation_8();
|
|
// @cmember S_OK - ISupportErrorInfo
|
|
int Variation_9();
|
|
// @cmember S_OK - IConvertType
|
|
int Variation_10();
|
|
// @cmember S_OK - IUnknown
|
|
int Variation_11();
|
|
};
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCMULTICMD_QueryInterface_FromSession)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::MultipleObjects
|
|
//
|
|
class TCMULTICMD_QueryInterface_FromSession : public TCMULTICMD_QueryInterface {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCMULTICMD_QueryInterface_FromSession,TCMULTICMD_QueryInterface);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCMULTICMD_QueryInterface_FromSession)
|
|
#define THE_CLASS TCMULTICMD_QueryInterface_FromSession
|
|
BEG_TEST_CASE(TCMULTICMD_QueryInterface_FromSession, TCMULTICMD_QueryInterface, L"IDBCreateCommand::MultipleObjects")
|
|
TEST_VARIATION(1, L"S_OK - ICommand")
|
|
TEST_VARIATION(2, L"S_OK - ICommandText")
|
|
TEST_VARIATION(3, L"S_OK - ICommandWithParameters")
|
|
TEST_VARIATION(4, L"S_OK - ICommandPrepare")
|
|
TEST_VARIATION(5, L"S_OK - ICommandProperties")
|
|
TEST_VARIATION(6, L"S_OK - IColumnsInfo")
|
|
TEST_VARIATION(7, L"S_OK - IColumnsRowset")
|
|
TEST_VARIATION(8, L"S_OK - IAccessor")
|
|
TEST_VARIATION(9, L"S_OK - ISupportErrorInfo")
|
|
TEST_VARIATION(10, L"S_OK - IConvertType")
|
|
TEST_VARIATION(11, L"S_OK - IUnknown")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCMULTICMD_QueryInterface_FromRow)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::MultipleObjects
|
|
//
|
|
class TCMULTICMD_QueryInterface_FromRow : public TCMULTICMD_QueryInterface {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCMULTICMD_QueryInterface_FromRow,TCMULTICMD_QueryInterface);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCMULTICMD_QueryInterface_FromRow)
|
|
#define THE_CLASS TCMULTICMD_QueryInterface_FromRow
|
|
BEG_TEST_CASE(TCMULTICMD_QueryInterface_FromRow, TCMULTICMD_QueryInterface, L"IDBCreateCommand::MultipleObjects")
|
|
TEST_VARIATION(1, L"S_OK - ICommand")
|
|
TEST_VARIATION(2, L"S_OK - ICommandText")
|
|
TEST_VARIATION(3, L"S_OK - ICommandWithParameters")
|
|
TEST_VARIATION(4, L"S_OK - ICommandPrepare")
|
|
TEST_VARIATION(5, L"S_OK - ICommandProperties")
|
|
TEST_VARIATION(6, L"S_OK - IColumnsInfo")
|
|
TEST_VARIATION(7, L"S_OK - IColumnsRowset")
|
|
TEST_VARIATION(8, L"S_OK - IAccessor")
|
|
TEST_VARIATION(9, L"S_OK - ISupportErrorInfo")
|
|
TEST_VARIATION(10, L"S_OK - IConvertType")
|
|
TEST_VARIATION(11, L"S_OK - IUnknown")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::ZombieCommand
|
|
//
|
|
class TCZOMBIE_Zombie : public TCZOMBIE {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
~TCZOMBIE_Zombie(void) {} ;
|
|
TCZOMBIE_Zombie( wchar_t* pwszTestCaseName) : TCZOMBIE(pwszTestCaseName) { };
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
// @cmember TestTxn
|
|
int TestTxn(ETXN eTxn, BOOL fRetaining);
|
|
|
|
// @cmember S_OK - Abort IDBCreateCommand with fRetaining=TRUE
|
|
int Variation_1();
|
|
// @cmember S_OK - Commit IDBCreateCommand with fRetaining=TRUE
|
|
int Variation_2();
|
|
// @cmember S_OK - Abort IDBCreateCommand with fRetaining=FALSE
|
|
int Variation_3();
|
|
// @cmember S_OK - Commit IDBCreateCommand with fRetaining=FALSE
|
|
int Variation_4();
|
|
|
|
};
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCZOMBIE_Zombie_FromSession)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::ZombieCommand
|
|
//
|
|
class TCZOMBIE_Zombie_FromSession : public TCZOMBIE_Zombie {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCZOMBIE_Zombie_FromSession,TCZOMBIE_Zombie);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCZOMBIE_Zombie_FromSession)
|
|
#define THE_CLASS TCZOMBIE_Zombie_FromSession
|
|
BEG_TEST_CASE(TCZOMBIE_Zombie_FromSession, TCZOMBIE_Zombie, L"IDBCreateCommand::ZombieCommand")
|
|
TEST_VARIATION(1, L"S_OK - Abort IDBCreateCommand with fRetaining=TRUE")
|
|
TEST_VARIATION(2, L"S_OK - Commit IDBCreateCommand with fRetaining=TRUE")
|
|
TEST_VARIATION(3, L"S_OK - Abort IDBCreateCommand with fRetaining=FALSE")
|
|
TEST_VARIATION(4, L"S_OK - Commit IDBCreateCommand with fRetaining=FALSE")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCZOMBIE_Zombie_FromRow)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::ZombieCommand
|
|
//
|
|
class TCZOMBIE_Zombie_FromRow : public TCZOMBIE_Zombie {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCZOMBIE_Zombie_FromRow,TCZOMBIE_Zombie);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCZOMBIE_Zombie_FromRow)
|
|
#define THE_CLASS TCZOMBIE_Zombie_FromRow
|
|
BEG_TEST_CASE(TCZOMBIE_Zombie_FromRow, TCZOMBIE_Zombie, L"IDBCreateCommand::ZombieCommand")
|
|
TEST_VARIATION(1, L"S_OK - Abort IDBCreateCommand with fRetaining=TRUE")
|
|
TEST_VARIATION(2, L"S_OK - Commit IDBCreateCommand with fRetaining=TRUE")
|
|
TEST_VARIATION(3, L"S_OK - Abort IDBCreateCommand with fRetaining=FALSE")
|
|
TEST_VARIATION(4, L"S_OK - Commit IDBCreateCommand with fRetaining=FALSE")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CommandLimit
|
|
//
|
|
class TCIDBCRCMD_CommandLimit : public TCIDBCRCMD {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
~TCIDBCRCMD_CommandLimit(void) {};
|
|
TCIDBCRCMD_CommandLimit( wchar_t* pwszTestCaseName) : TCIDBCRCMD(pwszTestCaseName) { };
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// @cmember S_OK - 100 Command Objects
|
|
int Variation_1();
|
|
// @cmember S_OK - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_TRUE
|
|
int Variation_2();
|
|
// @cmember DB_E_OBJECTOPEN - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_FALSE
|
|
int Variation_3();
|
|
};
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCIDBCRCMD_CommandLimit_FromSession)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CommandLimit
|
|
//
|
|
class TCIDBCRCMD_CommandLimit_FromSession : public TCIDBCRCMD_CommandLimit {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCIDBCRCMD_CommandLimit_FromSession,TCIDBCRCMD_CommandLimit);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCIDBCRCMD_CommandLimit_FromSession)
|
|
#define THE_CLASS TCIDBCRCMD_CommandLimit_FromSession
|
|
BEG_TEST_CASE(TCIDBCRCMD_CommandLimit_FromSession, TCIDBCRCMD_CommandLimit, L"IDBCreateCommand::CommandLimit")
|
|
TEST_VARIATION(1, L"S_OK - 100 Command Objects")
|
|
TEST_VARIATION(2, L"S_OK - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_TRUE")
|
|
TEST_VARIATION(3, L"DB_E_OBJECTOPEN - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_FALSE")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCIDBCRCMD_CommandLimit_FromRow)
|
|
//--------------------------------------------------------------------
|
|
// @class IDBCreateCommand::CommandLimit
|
|
//
|
|
class TCIDBCRCMD_CommandLimit_FromRow : public TCIDBCRCMD_CommandLimit {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCIDBCRCMD_CommandLimit_FromRow,TCIDBCRCMD_CommandLimit);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
// {{ TCW_TESTCASE(TCIDBCRCMD_CommandLimit_FromRow)
|
|
#define THE_CLASS TCIDBCRCMD_CommandLimit_FromRow
|
|
BEG_TEST_CASE(TCIDBCRCMD_CommandLimit_FromRow, TCIDBCRCMD_CommandLimit, L"IDBCreateCommand::CommandLimit")
|
|
TEST_VARIATION(1, L"S_OK - 100 Command Objects")
|
|
TEST_VARIATION(2, L"S_OK - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_TRUE")
|
|
TEST_VARIATION(3, L"DB_E_OBJECTOPEN - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_FALSE")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @class Extended Errors
|
|
//
|
|
class TCExtendedErrors : public TCIDBCRCMD {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
~TCExtendedErrors(void) {};
|
|
TCExtendedErrors( wchar_t* pwszTestCaseName) : TCIDBCRCMD(pwszTestCaseName) { };
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
|
|
// @cmember Valid IDBCreateCommand calls with previous error object existing.
|
|
int Variation_1();
|
|
// @cmember Invalid IDBCreateCommand calls with previous error object existing.
|
|
int Variation_2();
|
|
// @cmember Invalid IDBCreateCommand calls with no previous error object existing.
|
|
int Variation_3();
|
|
};
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCExtendedErrors_FromSession)
|
|
//--------------------------------------------------------------------
|
|
// @class Extended Errors
|
|
//
|
|
class TCExtendedErrors_FromSession : public TCExtendedErrors {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCExtendedErrors_FromSession,TCExtendedErrors);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
|
|
// {{ TCW_TESTCASE(TCExtendedErrors_FromSession)
|
|
#define THE_CLASS TCExtendedErrors_FromSession
|
|
BEG_TEST_CASE(TCExtendedErrors_FromSession, TCExtendedErrors, L"Extended Errors")
|
|
TEST_VARIATION(1, L"Valid IDBCreateCommand calls with previous error object existing.")
|
|
TEST_VARIATION(2, L"Invalid IDBCreateCommand calls with previous error object existing.")
|
|
TEST_VARIATION(3, L"Invalid IDBCreateCommand calls with no previous error object existing.")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// {{ TCW_TEST_CASE_MAP(TCExtendedErrors_FromRow)
|
|
//--------------------------------------------------------------------
|
|
// @class Extended Errors
|
|
//
|
|
class TCExtendedErrors_FromRow : public TCExtendedErrors {
|
|
private:
|
|
// @cmember Static array of variations
|
|
DECLARE_TEST_CASE_DATA();
|
|
|
|
public:
|
|
// {{ TCW_DECLARE_FUNCS
|
|
// @cmember Execution Routine
|
|
DECLARE_TEST_CASE_FUNCS(TCExtendedErrors_FromRow,TCExtendedErrors);
|
|
// }} TCW_DECLARE_FUNCS_END
|
|
|
|
// @cmember Initialization Routine
|
|
virtual BOOL Init();
|
|
// @cmember Termination Routine
|
|
virtual BOOL Terminate();
|
|
};
|
|
|
|
|
|
// {{ TCW_TESTCASE(TCExtendedErrors_FromRow)
|
|
#define THE_CLASS TCExtendedErrors_FromRow
|
|
BEG_TEST_CASE(TCExtendedErrors_FromRow, TCExtendedErrors, L"Extended Errors")
|
|
TEST_VARIATION(1, L"Valid IDBCreateCommand calls with previous error object existing.")
|
|
TEST_VARIATION(2, L"Invalid IDBCreateCommand calls with previous error object existing.")
|
|
TEST_VARIATION(3, L"Invalid IDBCreateCommand calls with no previous error object existing.")
|
|
END_TEST_CASE()
|
|
#undef THE_CLASS
|
|
// }} TCW_TESTCASE_END
|
|
// }} TCW_TEST_CASE_MAP_END
|
|
|
|
|
|
// }} END_DECLARE_TEST_CASES()
|
|
|
|
// {{ TCW_TESTMODULE(ThisModule)
|
|
TEST_MODULE(10, ThisModule, gwszModuleDescrip)
|
|
TEST_CASE(1, TCIDBCRCMD_CreateCommand_FromSession)
|
|
TEST_CASE(2, TCIDBCRCMD_CreateCommand_FromRow)
|
|
TEST_CASE(3, TCMULTICMD_QueryInterface_FromSession)
|
|
TEST_CASE(4, TCMULTICMD_QueryInterface_FromRow)
|
|
TEST_CASE(5, TCZOMBIE_Zombie_FromSession)
|
|
TEST_CASE(6, TCZOMBIE_Zombie_FromRow)
|
|
TEST_CASE(7, TCIDBCRCMD_CommandLimit_FromSession)
|
|
TEST_CASE(8, TCIDBCRCMD_CommandLimit_FromRow)
|
|
TEST_CASE(9, TCExtendedErrors_FromSession)
|
|
TEST_CASE(10, TCExtendedErrors_FromRow)
|
|
END_TEST_MODULE()
|
|
// }} TCW_TESTMODULE_END
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCIDBCRCMD_CreateCommand)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCIDBCRCMD_CreateCommand - IDBCreateCommand::CreateCommand
|
|
//| Created: 11/25/95
|
|
//| Updated: 04/25/98
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD::Init())
|
|
// }}
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_NOINTERFACE - Invalid REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_1()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = INVALID(ICommand*);
|
|
|
|
// IRowset isn't a valid REFIID on CreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_IRowset,
|
|
(IUnknown**)&pCommand), E_NOINTERFACE);
|
|
TESTC(!pCommand);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
if( pCommand != INVALID(ICommand*) )
|
|
SAFE_RELEASE(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_NOINTERFACE - IID_IDBInitialize REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_2()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = INVALID(ICommand*);
|
|
|
|
// IDBInitialize isn't a valid REFIID on CreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_IDBInitialize,
|
|
(IUnknown**)&pCommand), E_NOINTERFACE);
|
|
TESTC(!pCommand);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
if( pCommand != INVALID(ICommand*) )
|
|
SAFE_RELEASE(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_NOINTERFACE - IID_IDBCreateCommand REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_3()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = INVALID(ICommand*);
|
|
|
|
// IDBCreateCommand isn't a valid REFIID on CreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_IDBCreateCommand,
|
|
(IUnknown**)&pCommand), E_NOINTERFACE);
|
|
TESTC(!pCommand);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
if( pCommand != INVALID(ICommand*) )
|
|
SAFE_RELEASE(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(4)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc E_INVALIDARG - NULL pCommand
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_4()
|
|
{
|
|
TBEGIN;
|
|
|
|
// NULL pICommand on CreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommand, NULL), E_INVALIDARG);
|
|
|
|
CLEANUP:
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(5)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IID_ICommand for REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_5()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = NULL;
|
|
|
|
// CreateCommand with IID_ICommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&pCommand), S_OK);
|
|
TESTC(pCommand != NULL);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(6)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IID_ICommandText for REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_6()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = NULL;
|
|
|
|
// CreateCommand with IID_ICommandText
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommandText,
|
|
(IUnknown**)&pCommand), S_OK);
|
|
TESTC(pCommand != NULL);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(7)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IID_IColumnsInfo for REFIID
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CreateCommand::Variation_7()
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = NULL;
|
|
|
|
// CreateCommand with IID_IColumnsInfo
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_IColumnsInfo,
|
|
(IUnknown**)&pCommand), S_OK);
|
|
TESTC(pCommand != NULL);
|
|
|
|
CLEANUP:
|
|
|
|
// Release Object
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand_FromSession::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD_CreateCommand::Init())
|
|
// }}
|
|
{
|
|
// QueryInterface for a IDBCreateSession
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown, IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBCreateSession));
|
|
|
|
// QueryInterface for a IDBCreateCommand
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown2, IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&m_pIDBCreateCommand));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CLEANUP:
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand_FromSession::Terminate()
|
|
{
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand_FromRow::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD_CreateCommand::Init())
|
|
// }}
|
|
{
|
|
return InitializeRowObject();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CreateCommand_FromRow::Terminate()
|
|
{
|
|
// Destroy the row object
|
|
SAFE_DELETE(m_pCRowObject);
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCMULTICMD_QueryInterface)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCMULTICMD_QueryInterface - IDBCreateCommand::MultipleObjects
|
|
//| Created: 11/25/95
|
|
//| Updated: 04/25/98
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCMULTICMD::Init())
|
|
// }}
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ICommand
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_1()
|
|
{
|
|
// ICommand REFIID is mandatory
|
|
return TestInterface(IID_ICommand,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ICommandText
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_2()
|
|
{
|
|
// ICommandText REFIID is mandatory
|
|
return TestInterface(IID_ICommandText,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ICommandWithParameters
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_3()
|
|
{
|
|
// ICommandWithParameters REFIID is not mandatory
|
|
return TestInterface(IID_ICommandWithParameters,FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(4)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ICommandPrepare
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_4()
|
|
{
|
|
// ICommandPrepare REFIID is not mandatory
|
|
return TestInterface(IID_ICommandPrepare,FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(5)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ICommandProperties
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_5()
|
|
{
|
|
// ICommandProperties REFIID is mandatory
|
|
return TestInterface(IID_ICommandProperties,FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(6)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IColumnsInfo
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_6()
|
|
{
|
|
// IColumnsInfo REFIID is mandatory
|
|
return TestInterface(IID_IColumnsInfo,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(7)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IColumnsRowset
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_7()
|
|
{
|
|
// IColumnsRowset REFIID is not mandatory
|
|
return TestInterface(IID_IColumnsRowset,FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(8)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IAccessor
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_8()
|
|
{
|
|
// IAccessor REFIID is mandatory
|
|
return TestInterface(IID_IAccessor,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(9)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - ISupportErrorInfo
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_9()
|
|
{
|
|
// ISupportErrorInfo REFIID is not mandatory
|
|
return TestInterface(IID_ISupportErrorInfo,FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(10)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IConvertType
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_10()
|
|
{
|
|
// IConvertType REFIID is mandatory
|
|
return TestInterface(IID_IConvertType,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(11)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - IUnknown
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCMULTICMD_QueryInterface::Variation_11()
|
|
{
|
|
// IUnknown REFIID is mandatory
|
|
return TestInterface(IID_IUnknown,TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCMULTICMD::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface_FromSession::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCMULTICMD_QueryInterface::Init())
|
|
// }}
|
|
{
|
|
// QueryInterface for a IDBCreateSession
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown, IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBCreateSession));
|
|
|
|
// QueryInterface for a IDBCreateCommand
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown2, IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&m_pIDBCreateCommand));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CLEANUP:
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface_FromSession::Terminate()
|
|
{
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCMULTICMD_QueryInterface::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface_FromRow::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCMULTICMD_QueryInterface::Init())
|
|
// }}
|
|
{
|
|
return InitializeRowObject();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCMULTICMD_QueryInterface_FromRow::Terminate()
|
|
{
|
|
// Destroy the row object
|
|
SAFE_DELETE(m_pCRowObject);
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCMULTICMD_QueryInterface::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCZOMBIE_Zombie)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCZOMBIE_Zombie - IDBCreateCommand::ZombieCommand
|
|
//| Created: 11/08/95
|
|
//| Updated: 04/25/98
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie::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(TCZOMBIE::Init())
|
|
// }}
|
|
{
|
|
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 S_OK - Abort IDBCreateCommand with fRetaining=TRUE
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCZOMBIE_Zombie::Variation_1()
|
|
{
|
|
// S_OK - Abort IDBCreateCommand with fRetaining=TRUE
|
|
return TestTxn(ETXN_ABORT, TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - Commit IDBCreateCommand with fRetaining=TRUE
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCZOMBIE_Zombie::Variation_2()
|
|
{
|
|
// S_OK - Commit IDBCreateCommand with fRetaining=TRUE
|
|
return TestTxn(ETXN_COMMIT, TRUE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - Abort IDBCreateCommand with fRetaining=FALSE
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCZOMBIE_Zombie::Variation_3()
|
|
{
|
|
// S_OK - Abort IDBCreateCommand with fRetaining=FALSE
|
|
return TestTxn(ETXN_ABORT, FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(4)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - Commit IDBCreateCommand with fRetaining=FALSE
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCZOMBIE_Zombie::Variation_4()
|
|
{
|
|
// S_OK - Commit IDBCreateCommand with fRetaining=FALSE
|
|
return TestTxn(ETXN_COMMIT, FALSE);
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCZOMBIE::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie_FromSession::Init()
|
|
{
|
|
BOOL fPass = TCZOMBIE_Zombie::Init();
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(fPass == TRUE)
|
|
// }}
|
|
{
|
|
m_fRowCommand = FALSE;
|
|
return RegisterInterface(SESSION_INTERFACE,IID_IDBCreateCommand,0,NULL);
|
|
}
|
|
|
|
return fPass;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie_FromSession::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCZOMBIE_Zombie::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie_FromRow::Init()
|
|
{
|
|
BOOL fPass = TCZOMBIE_Zombie::Init();
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(fPass == TRUE)
|
|
// }}
|
|
{
|
|
m_fRowCommand = TRUE;
|
|
// Even if IDBCreateCommand is support on the session,
|
|
// it may not be supported on a row object
|
|
if(!RegisterInterface(ROW_INTERFACE,IID_IDBCreateCommand,0,NULL))
|
|
return TEST_SKIPPED;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
return fPass;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCZOMBIE_Zombie_FromRow::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCZOMBIE_Zombie::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCIDBCRCMD_CommandLimit)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCIDBCRCMD_CommandLimit - IDBCreateCommand::CommandLimit
|
|
//| Created: 11/25/95
|
|
//| Updated: 04/25/98
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD::Init())
|
|
// }}
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - 100 Command Objects
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CommandLimit::Variation_1()
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
ICommand* rgpCommand[MAX_CMDOBJ];
|
|
HRESULT hr = E_FAIL;
|
|
ULONG udCmdCount = 0;
|
|
|
|
// LOOP 100 times creating ICommands
|
|
for(udCmdCount=0; udCmdCount < MAX_CMDOBJ; udCmdCount++)
|
|
{
|
|
// ICommand REFIID on IDBCreateCommand
|
|
hr=m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[udCmdCount]);
|
|
|
|
// If this fails on the 1st CreateCommand return E_FAIL
|
|
if((hr != S_OK) || (!rgpCommand[udCmdCount]))
|
|
{
|
|
// Return FALSE because of an ERROR
|
|
if(((hr == S_OK) && (!rgpCommand[udCmdCount])) ||
|
|
((hr != S_OK) && (!udCmdCount)))
|
|
fSuccess = FALSE;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Display the number of Commands created
|
|
odtLog <<L"IDBCreateCommand created " <<udCmdCount <<L" objects." <<ENDL;
|
|
|
|
// Checking ref count is correct after release
|
|
for(udCmdCount; udCmdCount > 0; udCmdCount--)
|
|
SAFE_RELEASE_(rgpCommand[udCmdCount-1]);
|
|
|
|
// Create 1 more ICommand to see if Release really worked
|
|
if(!CHECK(hr=m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[0]), S_OK) || (!rgpCommand[0]))
|
|
fSuccess = FALSE;
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE_(rgpCommand[0]);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc S_OK - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_TRUE
|
|
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CommandLimit::Variation_2()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
ICommand* rgpCommand[2];
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// Check to see if the provider supports DBPROP_MULTIPLECONNECTIONS
|
|
if( !::GetProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE, m_pIDBCreateSession) ||
|
|
!SettableProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE, m_pIDBCreateSession) )
|
|
{
|
|
odtLog << L"DBPROP_MULTIPLECONNECTIONS can not be set to VARIANT_TRUE." << ENDL;
|
|
return TEST_SKIPPED;
|
|
}
|
|
|
|
// ICommand REFIID on IDBCreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[0]),S_OK);
|
|
|
|
// ICommand REFIID on IDBCreateCommand
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[1]),S_OK);
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(rgpCommand[0]);
|
|
|
|
// Create 1 more ICommand to see if Release really worked
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[0]), S_OK);
|
|
|
|
COMPARE(rgpCommand[1] != NULL, TRUE);
|
|
fSuccess = TRUE;
|
|
|
|
CLEANUP:
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(rgpCommand[0]);
|
|
SAFE_RELEASE_(rgpCommand[1]);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc DB_E_OBJECTOPEN - 2 Command Objects with DBPROP_MULTIPLECONNECTIONS set to VARIANT_FALSE
|
|
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCIDBCRCMD_CommandLimit::Variation_3()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cPropSets = 0;
|
|
DBPROPSET * rgPropSets = NULL;
|
|
ICommand* rgpCommand[2] = {NULL,NULL};
|
|
IDBProperties * pIDBProperties = NULL;
|
|
IDBCreateSession * pIDBCreateSession = NULL;
|
|
IDBCreateCommand * pIDBCreateCommand = NULL;
|
|
|
|
// Create a fresh DataSource
|
|
TESTC_(GetModInfo()->CreateProvider(NULL,IID_IDBProperties,
|
|
(IUnknown**)&pIDBProperties), S_OK);
|
|
|
|
TESTC_(InitializeDataSource(pIDBProperties), S_OK);
|
|
|
|
// Check to see if the provider supports DBPROP_MULTIPLECONNECTIONS
|
|
if( !SupportedProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE, pIDBProperties) ||
|
|
(::GetProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE, pIDBProperties) &&
|
|
!SettableProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE, pIDBProperties)) )
|
|
{
|
|
odtLog << L"DBPROP_MULTIPLECONNECTIONS can not be set to VARIANT_FALSE." << ENDL;
|
|
SAFE_RELEASE(pIDBProperties);
|
|
return TEST_SKIPPED;
|
|
}
|
|
|
|
// Set the Property to VARIANT_TRUE
|
|
TESTC_(::SetProperty(DBPROP_MULTIPLECONNECTIONS, DBPROPSET_DATASOURCE,
|
|
&cPropSets, &rgPropSets, DBTYPE_BOOL, (ULONG_PTR) VARIANT_FALSE), S_OK);
|
|
|
|
TESTC_(pIDBProperties->SetProperties(cPropSets, rgPropSets), S_OK);
|
|
|
|
// Get a new Session object
|
|
QTESTC(VerifyInterface(pIDBProperties, IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&pIDBCreateSession));
|
|
|
|
TESTC_(pIDBCreateSession->CreateSession(NULL, IID_IDBCreateCommand,
|
|
(IUnknown**)&pIDBCreateCommand), S_OK);
|
|
|
|
// ICommand REFIID on IDBCreateCommand
|
|
TESTC_(pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[0]),S_OK);
|
|
|
|
// ICommand REFIID on IDBCreateCommand
|
|
TEST2C_(pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[1]),S_OK,DB_E_OBJECTOPEN);
|
|
SAFE_RELEASE(rgpCommand[1]);
|
|
|
|
TEST2C_(pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&rgpCommand[1]),S_OK,DB_E_OBJECTOPEN);
|
|
fSuccess = TRUE;
|
|
|
|
CLEANUP:
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(rgpCommand[0]);
|
|
SAFE_RELEASE_(rgpCommand[1]);
|
|
SAFE_RELEASE(pIDBProperties);
|
|
SAFE_RELEASE(pIDBCreateCommand);
|
|
SAFE_RELEASE(pIDBCreateSession);
|
|
::FreeProperties(&cPropSets, &rgPropSets);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit_FromSession::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD_CommandLimit::Init())
|
|
// }}
|
|
{
|
|
// IDBCreateSession
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown,IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBCreateSession));
|
|
|
|
// IDBCreateCommand
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown2,IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&m_pIDBCreateCommand));
|
|
return TRUE;
|
|
}
|
|
|
|
CLEANUP:
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit_FromSession::Terminate()
|
|
{
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD_CommandLimit::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit_FromRow::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD_CommandLimit::Init())
|
|
// }}
|
|
{
|
|
return InitializeRowObject();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD_CommandLimit_FromRow::Terminate()
|
|
{
|
|
// Destroy the row object
|
|
SAFE_DELETE(m_pCRowObject);
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD_CommandLimit::Terminate());
|
|
} // }}
|
|
// }}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TC_PROTOTYPE(TCExtendedErrors)
|
|
//*-----------------------------------------------------------------------
|
|
//| Test Case: TCExtendedErrors - Extended Errors
|
|
//| Created: 07/11/96
|
|
//| Updated: 04/25/98
|
|
//*-----------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCIDBCRCMD::Init())
|
|
// }}
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(1)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Valid IDBCreateCommand calls with previous error object existing.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCExtendedErrors::Variation_1()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
ICommand* pCommand = NULL;
|
|
|
|
// Cause an Error
|
|
m_pExtError->CauseError();
|
|
|
|
// CreateCommand with IID_ICommand
|
|
if(CHECK(hr=m_pIDBCreateCommand->CreateCommand(NULL, IID_ICommand,
|
|
(IUnknown**)&pCommand), S_OK) && (pCommand))
|
|
fSuccess = TRUE;
|
|
|
|
// Do extended check following CreateCommand
|
|
fSuccess &= XCHECK(m_pIDBCreateCommand, IID_IDBCreateCommand, hr);
|
|
|
|
// Release the Command
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(2)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Invalid IDBCreateCommand calls with previous error object existing.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCExtendedErrors::Variation_2()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
ICommand* pCommand = NULL;
|
|
|
|
// Cause an Error
|
|
m_pExtError->CauseError();
|
|
|
|
// IID_IDBCreateCommand REFIID on CreateCommand
|
|
if(CHECK(hr=m_pIDBCreateCommand->CreateCommand(NULL, IID_IDBCreateCommand,
|
|
(IUnknown**)&pCommand), E_NOINTERFACE) && (!pCommand))
|
|
fSuccess = TRUE;
|
|
|
|
//Do extended check following CreateCommand
|
|
fSuccess &= XCHECK(m_pIDBCreateCommand, IID_IDBCreateCommand, hr);
|
|
|
|
// Release the Command
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_VAR_PROTOTYPE(3)
|
|
//*-----------------------------------------------------------------------
|
|
// @mfunc Invalid IDBCreateCommand calls with no previous error object existing.
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCExtendedErrors::Variation_3()
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// NULL pICommand on CreateCommand
|
|
if(CHECK(hr=m_pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommand, NULL), E_INVALIDARG))
|
|
fSuccess = TRUE;
|
|
|
|
// Do extended check following CreateCommand
|
|
fSuccess &= XCHECK(m_pIDBCreateCommand, IID_IDBCreateCommand, hr);
|
|
|
|
if(fSuccess)
|
|
return TEST_PASS;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
// }}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors::Terminate()
|
|
{
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCIDBCRCMD::Terminate());
|
|
} // }}
|
|
|
|
// }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors_FromSession::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCExtendedErrors::Init())
|
|
// }}
|
|
{
|
|
// IDBCreateSession
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown,IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBCreateSession));
|
|
|
|
// IDBCreateCommand
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown2,IID_IDBCreateCommand,
|
|
SESSION_INTERFACE, (IUnknown**)&m_pIDBCreateCommand));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CLEANUP:
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors_FromSession::Terminate()
|
|
{
|
|
// Release Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCExtendedErrors::Terminate());
|
|
} // }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Initialization Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors_FromRow::Init()
|
|
{
|
|
// {{ TCW_INIT_BASECLASS_CHECK
|
|
if(TCExtendedErrors::Init())
|
|
// }}
|
|
{
|
|
return InitializeRowObject();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// {{ TCW_TERMINATE_METHOD
|
|
//--------------------------------------------------------------------
|
|
// @mfunc TestCase Termination Routine
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCExtendedErrors_FromRow::Terminate()
|
|
{
|
|
// Destroy the row object
|
|
SAFE_DELETE(m_pCRowObject);
|
|
|
|
// Release the Interfaces
|
|
SAFE_RELEASE(m_pIDBCreateCommand);
|
|
SAFE_RELEASE(m_pIDBCreateSession);
|
|
|
|
// {{ TCW_TERM_BASECLASS_CHECK2
|
|
return(TCExtendedErrors::Terminate());
|
|
} // }}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc Create a row object and try to QI for IDBCreateCommand
|
|
//
|
|
// @rdesc TRUE or FALSE
|
|
//
|
|
BOOL TCIDBCRCMD::InitializeRowObject()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
CRowset Rowset;
|
|
|
|
m_pCRowObject = NULL;
|
|
m_pIDBCreateCommand = NULL;
|
|
m_pIDBCreateSession = NULL;
|
|
|
|
// IDBCreateSession
|
|
TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown,IID_IDBCreateSession,
|
|
DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBCreateSession));
|
|
|
|
//Create a new row object
|
|
m_pCRowObject = new CRowObject;
|
|
TESTC(m_pCRowObject != NULL);
|
|
|
|
//Create the Rowset object and obtain first row
|
|
hr = Rowset.CreateRowset();
|
|
if (hr==DB_E_NOTSUPPORTED)
|
|
TESTC_PROVIDER(FALSE);
|
|
|
|
TESTC_(hr, S_OK);
|
|
TESTC_(Rowset.GetNextRows(&m_hRow),S_OK);
|
|
|
|
//Now create the row object.
|
|
QTESTC(SUCCEEDED(hr = m_pCRowObject->CreateRowObject(Rowset.pIRowset(), m_hRow)));
|
|
Rowset.ReleaseRows(m_hRow);
|
|
|
|
if(!VerifyInterface(m_pCRowObject->pIRow(), IID_IDBCreateCommand, ROW_INTERFACE,(IUnknown**)&m_pIDBCreateCommand))
|
|
return TEST_SKIPPED;
|
|
|
|
return TEST_PASS;
|
|
|
|
CLEANUP:
|
|
if (hr==E_NOINTERFACE || hr==DB_E_NOTSUPPORTED)
|
|
return TEST_SKIPPED;
|
|
else
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc Test Interface Routine
|
|
//
|
|
// @rdesc S_OK or E_FAIL
|
|
//
|
|
int TCMULTICMD::TestInterface(IID iid, BOOL mandatory)
|
|
{
|
|
TBEGIN;
|
|
|
|
ICommand* pCommand = NULL;
|
|
IUnknown* pIUnknown = NULL;
|
|
|
|
// Check the levels
|
|
if( mandatory || IsReqInterface(COMMAND_INTERFACE, iid) )
|
|
{
|
|
// CreateCommand with a mandatory interface should return S_OK
|
|
TESTC_(m_pIDBCreateCommand->CreateCommand(NULL, iid, (IUnknown**)&pCommand), S_OK);
|
|
TESTC(DefaultObjectTesting(pCommand, COMMAND_INTERFACE));
|
|
}
|
|
else
|
|
{
|
|
// CreateCommand should return S_OK or E_NOINTERFACE
|
|
HRESULT hr=m_pIDBCreateCommand->CreateCommand(NULL, iid, (IUnknown**)&pCommand);
|
|
|
|
// Check the returncode and pointer
|
|
if( hr == E_NOINTERFACE ) {
|
|
TESTC(!pCommand);
|
|
}
|
|
else {
|
|
TESTC(DefaultObjectTesting(pCommand, COMMAND_INTERFACE));
|
|
}
|
|
}
|
|
|
|
CLEANUP:
|
|
|
|
// Release Interfaces
|
|
SAFE_RELEASE(pIUnknown);
|
|
SAFE_RELEASE_(pCommand);
|
|
|
|
TRETURN;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @mfunc Test Zombie cases
|
|
//
|
|
// @rdesc TEST_PASS or TEST_FAIL
|
|
//
|
|
int TCZOMBIE_Zombie::TestTxn(ETXN eTxn, BOOL fRetaining)
|
|
{
|
|
int fPassFail = TEST_FAIL; // ReturnValue
|
|
HRESULT ExpectedHr = E_UNEXPECTED; // Expected HRESULT
|
|
DBCOUNTITEM cRowsObtained = 0; // Number of rows returned, should be 1
|
|
HROW * rghRows = NULL; // Array of Row Handles
|
|
IDBCreateCommand * pIDBCreateCommand = NULL; // IDBCreateCommand
|
|
ICommand * pICommand = NULL; // ICommand Pointer
|
|
|
|
// Retrieve an Interface pointer to IDBCreateCommand within a Transaction
|
|
TESTC(StartTransaction(SELECT_ALLFROMTBL, (IUnknown**)&pIDBCreateCommand));
|
|
|
|
// Obtain the ABORT or COMMIT PRESERVE flag and adjust ExpectedHr
|
|
if( ((eTxn == ETXN_COMMIT) && (m_fCommitPreserve)) ||
|
|
((eTxn == ETXN_ABORT) && (m_fAbortPreserve)) )
|
|
ExpectedHr = S_OK;
|
|
|
|
// Commit or Abort the transaction, with retention as specified
|
|
if( eTxn == ETXN_COMMIT )
|
|
TESTC(GetCommit(fRetaining));
|
|
|
|
if( eTxn == ETXN_ABORT )
|
|
TESTC(GetAbort(fRetaining));
|
|
|
|
// Test zombie
|
|
TESTC_(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
|
|
|
|
// Release the row handle on the 1st rowset
|
|
TESTC_(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), S_OK);
|
|
PROVIDER_FREE(rghRows);
|
|
|
|
// Cleanup Transactions
|
|
CleanUpTransaction(fRetaining ? S_OK : XACT_E_NOTRANSACTION);
|
|
|
|
if( m_fRowCommand )
|
|
{
|
|
// CreateCommand with IID_ICommand
|
|
TESTC_(pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommand, (IUnknown**)&pICommand), ExpectedHr);
|
|
fPassFail = TEST_PASS;
|
|
}
|
|
else
|
|
{
|
|
// CreateCommand with IID_ICommand
|
|
TESTC_(pIDBCreateCommand->CreateCommand(NULL,
|
|
IID_ICommand, (IUnknown**)&pICommand), S_OK);
|
|
fPassFail = TEST_PASS;
|
|
}
|
|
|
|
CLEANUP:
|
|
|
|
// Release the ICommand and IDBCreateCommand
|
|
SAFE_RELEASE_(pICommand);
|
|
SAFE_RELEASE(pIDBCreateCommand);
|
|
|
|
return fPassFail;
|
|
}
|