//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright 1995-2000 Microsoft Corporation.  
//
// @doc 
//
// @module IDBINFO.CPP | Source code for autotest IDBINFO.CPP.
//

#include "MODStandard.hpp"
#define  DBINITCONSTANTS	// Must be defined to initialize constants in OLEDB.H
#define  INITGUID
#include "IDBInfo.h"

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0xd6bf9810, 0xd00c, 0x11ce, { 0x98, 0x77, 0x00, 0xaa, 0x00, 0x37, 0xda, 0x9b }};
DECLARE_MODULE_NAME("IDBInfo");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("Test module for IDBInfo Interfaces");
DECLARE_MODULE_VERSION(831585464);
// 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)
{
	IDBInfo* pIDBInfo = NULL;
	BOOL bValue = FALSE;

	if(ModuleCreateDBSession(pThisTestModule))
	{
		// IDBInfo
		if(!VerifyInterface(pThisTestModule->m_pIUnknown, IID_IDBInfo,
								DATASOURCE_INTERFACE, (IUnknown**)&pIDBInfo))
		{
			odtLog << L"IDBInfo is not supported by this Provider." << ENDL;
			return TEST_SKIPPED;
		}

		bValue = TRUE;
	}

	// Release the Interfaces
	SAFE_RELEASE(pIDBInfo);
	return bValue;
}	
  
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// 		@flag  TRUE  | Successful initialization
//		@flag  FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
	// Free the interface we got in ModuleCreateDBSession()
	return ModuleReleaseDBSession(pThisTestModule);
}	


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Base Class
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class DBProp : public CDataSourceObject
{

protected:
	// @cmember If the variation passed
	BOOL			m_fSucceed;
	// @cmember Interface pointer
	IDBInfo *		m_pIDBInfo;
	// @cmember Count of DBLITERAL objects
	ULONG			m_cLiterals;
	// @cmember Array of DBLITERAL objects
	DBLITERAL *		m_rgLiterals;
	// @cmember Count of DBLITERALINFO objects
	ULONG 			m_cLiteralInfo;
	// @cmember Array of DBLITERALINFO objects
	DBLITERALINFO *	m_rgLiteralInfo;
	// @cmember Character Buffer for GetLiteralInfo
	WCHAR *			m_pCharBuffer;
	// @cmember Buffer of keywords
	LPWSTR			m_pwszKeywords;
	
	// @cmember Constructor
	DBProp(LPWSTR wszTestCaseName): CDataSourceObject(wszTestCaseName)
	{
		// Initialize the members
		m_cLiterals		= 0;
		m_cLiteralInfo	= 0;

		m_pIDBInfo		= NULL;
		m_rgLiterals	= NULL;
 		m_rgLiteralInfo	= NULL;
  		m_pCharBuffer	= NULL;
		m_pwszKeywords	= NULL;
		
		m_hr			= E_FAIL;
		m_fSucceed		= FALSE;
	};

	// @cmember Destructor
	virtual ~DBProp(){};

	// @cmember Test Case Initialization
	BOOL Init();

	// @cmember Test Case Termination
	BOOL Terminate();
	
	// @cember Test Variation Initialization
	BOOL InitVar();
	
	// @cmember Test Variation Termination
	BOOL TermVar();
	
	// @cmember Verify results of GetKeywords
	BOOL KeywordsVerify(HRESULT hr);
	
	// @cmember Verify results of GetLiteralInfo
	BOOL LiteralsVerify(HRESULT hr, BOOL fToScreen=FALSE);
	
	// @cmember Arrange DBLITERAL objects for GetLiteralInfo
	BOOL ArrangeLiterals(ARRANGELITERAL eArrangeLiteral);
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Init for Test Case
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::Init()
{
  	if(CDataSourceObject::Init())
	{	
		// IDBInitialize
		TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown, IID_IDBInitialize, 
							DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBInitialize));
		
		// Get interface pointer for test case
		TESTC(VerifyInterface(m_pIDBInitialize, IID_IDBInfo, 
						DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBInfo));

		// Release the Session Object
		SAFE_RELEASE(m_pThisTestModule->m_pIUnknown2);
		return TRUE;
	}

CLEANUP:
	
	return FALSE;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Terminate for Test Case
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::Terminate()
{
	// Release the objects
	SAFE_RELEASE(m_pIDBInfo);
	ReleaseDataSourceObject();

	return CDataSourceObject::Terminate();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Init for Test Case Variation
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::InitVar()
{
	// Initialize the members
	m_cLiterals		= 0;
	m_cLiteralInfo  = 0;

	m_rgLiterals	= NULL;
	m_rgLiteralInfo = NULL;
  	m_pCharBuffer	= NULL;
	m_pwszKeywords	= NULL;

	m_hr			= E_FAIL;
	m_fSucceed		= FALSE;

	return TRUE;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Terminate for Test Case Variation
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::TermVar()
{
	// Clean everything up	
	if( (m_rgLiteralInfo) && 
		(m_rgLiteralInfo != INVALID(DBLITERALINFO*)) )
		PROVIDER_FREE(m_rgLiteralInfo);
 	
	if( (m_pCharBuffer) && 
		(m_pCharBuffer != INVALID(OLECHAR*)) )
		PROVIDER_FREE(m_pCharBuffer);
	
	if( (m_pwszKeywords) && 
		(m_pwszKeywords != INVALID(OLECHAR*)) )
		PROVIDER_FREE(m_pwszKeywords);

	PROVIDER_FREE(m_rgLiterals);
	
	return TRUE;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


// {{ TCW_TEST_CASE_MAP(Keywords)
//--------------------------------------------------------------------
// @class testing keywords
//
class Keywords : public DBProp { 
private:
	// @cmember Static array of variations
	DECLARE_TEST_CASE_DATA();
	
public:
	// {{ TCW_DECLARE_FUNCS
	// @cmember Execution Routine
	DECLARE_TEST_CASE_FUNCS(Keywords,DBProp);
	// }} TCW_DECLARE_FUNCS_END
 
	// @cmember Initialization Routine
	virtual BOOL Init();
	// @cmember Termination Routine
	virtual BOOL Terminate();
	
	// {{ TCW_TESTVARS()
	// @cmember S_OK
	int Variation_1();
	// @cmember E_INVALIDARG
	int Variation_2();
	// @cmember E_UNEXPECTED
	int Variation_3();
	// }} TCW_TESTVARS_END
};

// {{ TCW_TESTCASE(Keywords)
#define THE_CLASS Keywords
BEG_TEST_CASE(Keywords, DBProp, L"testing keywords")
	TEST_VARIATION(1, 		L"S_OK")
	TEST_VARIATION(2, 		L"E_INVALIDARG")
	TEST_VARIATION(3, 		L"E_UNEXPECTED")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END


// {{ TCW_TEST_CASE_MAP(LiteralInfo)
//--------------------------------------------------------------------
// @class testing LiteralInfo
//
class LiteralInfo : public DBProp { 
private:
	// @cmember Static array of variations
	DECLARE_TEST_CASE_DATA();
	
public:
	// {{ TCW_DECLARE_FUNCS
	// @cmember Execution Routine
	DECLARE_TEST_CASE_FUNCS(LiteralInfo,DBProp);
	// }} TCW_DECLARE_FUNCS_END
 
	// @cmember Initialization Routine
	virtual BOOL Init();
	// @cmember Termination Routine
	virtual BOOL Terminate();
	
	// {{ TCW_TESTVARS()
	// @cmember S_OK - cLiterals == 0
	int Variation_1();
	// @cmember S_OK - cLiterals == 1
	int Variation_2();
	// @cmember S_OK - cLiterals == ALL Literals
	int Variation_3();
	// @cmember E_INVALIDARG - cLiterals != 0, and rgLiterals == NULL
	int Variation_4();
	// @cmember E_INVALIDARG - pcLiteralInfo was a null pointer
	int Variation_5();
	// @cmember E_INVALIDARG - prgLiteralInfo was a null pointer
	int Variation_6();
	// @cmember E_INVALIDARG - pCharBuffer was a null pointer
	int Variation_7();
	// @cmember S_OK - Half of valid literals
	int Variation_8();
	// @cmember S_OK - Reverse of all valid literals
	int Variation_9();
	// @cmember S_OK - rgLiterals contained at least 1 unsupported or invalid literal with cLiterals = 0
	int Variation_10();
	// @cmember S_OK - all literals invalid or unsupported with cLiterals = 0
	int Variation_11();
	// @cmember DB_S_ERRORSOCCURRED - rgLiterals contained at least 1 unsupported or invalid literal
	int Variation_12();
	// @cmember DB_E_ERRORSOCCURRED - all literals invalid or unsupported
	int Variation_13();
	// @cmember E_UNEXPECTED - Uninitialized
	int Variation_14();
	// @cmember S_OK - 2.x Provider has both QUOTE_PREFIX and QUOTE_SUFFIX
	int Variation_15();
	// @cmember S_OK - Check for both CATALOG_NAME and CATALOG_SEPARATOR
	int Variation_16();
	// @cmember S_OK - 2.x Provider has both SCHEMA_NAME and SCHEMA_SEPARATOR
	int Variation_17();
	// @cmember S_OK - cLiterals == ALL Literals multiple times
	int Variation_18();
	// }} TCW_TESTVARS_END
};

// {{ TCW_TESTCASE(LiteralInfo)
#define THE_CLASS LiteralInfo
BEG_TEST_CASE(LiteralInfo, DBProp, L"testing LiteralInfo")
	TEST_VARIATION(1, 		L"S_OK - cLiterals == 0")
	TEST_VARIATION(2, 		L"S_OK - cLiterals == 1")
	TEST_VARIATION(3, 		L"S_OK - cLiterals == ALL Literals")
	TEST_VARIATION(4, 		L"E_INVALIDARG - cLiterals != 0, and rgLiterals == NULL")
	TEST_VARIATION(5, 		L"E_INVALIDARG - pcLiteralInfo was a null pointer")
	TEST_VARIATION(6, 		L"E_INVALIDARG - prgLiteralInfo was a null pointer")
	TEST_VARIATION(7, 		L"E_INVALIDARG - pCharBuffer was a null pointer")
	TEST_VARIATION(8, 		L"S_OK - Half of valid literals")
	TEST_VARIATION(9, 		L"S_OK - Reverse of all valid literals")
	TEST_VARIATION(10, 		L"S_OK - rgLiterals contained at least 1 unsupported or invalid literal with cLiterals = 0")
	TEST_VARIATION(11, 		L"S_OK - all literals invalid or unsupported with cLiterals = 0")
	TEST_VARIATION(12, 		L"DB_S_ERRORSOCCURRED - rgLiterals contained at least 1 unsupported or invalid literal")
	TEST_VARIATION(13, 		L"DB_E_ERRORSOCCURRED - all literals invalid or unsupported")
	TEST_VARIATION(14, 		L"E_UNEXPECTED - Uninitialized")
	TEST_VARIATION(15, 		L"S_OK - 2.x Provider has both QUOTE_PREFIX and QUOTE_SUFFIX")
	TEST_VARIATION(16, 		L"S_OK - Check for both CATALOG_NAME and CATALOG_SEPARATOR")
	TEST_VARIATION(17, 		L"S_OK - 2.x Provider has both SCHEMA_NAME and SCHEMA_SEPARATOR")
	TEST_VARIATION(18, 		L"S_OK - cLiterals == ALL Literals multiple times")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END

// {{ TCW_TEST_CASE_MAP(TCZOMBIE_Zombie)
//--------------------------------------------------------------------
// @class Induce zombie states
//
class TCZOMBIE_Zombie : public CTransaction { 
private:
	// @cmember Static array of variations
	DECLARE_TEST_CASE_DATA();
	
public:
	// {{ TCW_DECLARE_FUNCS
	// @cmember Execution Routine
	DECLARE_TEST_CASE_FUNCS(TCZOMBIE_Zombie,CTransaction);
	// }} TCW_DECLARE_FUNCS_END

	// @cmember Initialization Routine
	virtual BOOL Init();
	// @cmember Termination Routine
	virtual BOOL Terminate();

	// @cmember IDBInfo object
	IDBInfo *		m_pIDBInfo;
	
	// @cmember TestTxn
	int TestTxn(ETXN eTxn, BOOL fRetaining);
	
	// {{ TCW_TESTVARS()
	// @cmember S_OK - Commit IDBInfo with fRetaining=TRUE
	int Variation_1();
	// @cmember S_OK - Commit IDBInfo with fRetaining=FALSE
	int Variation_2();
	// @cmember S_OK - Abort IDBInfo with fRetaining=TRUE
	int Variation_3();
	// @cmember S_OK - Abort IDBInfo with fRetaining=FALSE
	int Variation_4();
	// }} TCW_TESTVARS_END
};

// {{ TCW_TESTCASE(TCZOMBIE_Zombie)
#define THE_CLASS TCZOMBIE_Zombie
BEG_TEST_CASE(TCZOMBIE_Zombie, CTransaction, L"Induce zombie states")
	TEST_VARIATION(1, 		L"S_OK - Commit IDBInfo with fRetaining=TRUE")
	TEST_VARIATION(2, 		L"S_OK - Commit IDBInfo with fRetaining=FALSE")
	TEST_VARIATION(3, 		L"S_OK - Abort IDBInfo with fRetaining=TRUE")
	TEST_VARIATION(4, 		L"S_OK - Abort IDBInfo with fRetaining=FALSE")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END

// {{ TCW_TEST_CASE_MAP(TCExtendedErrors)
//--------------------------------------------------------------------
// @class Extended Errors
//
class TCExtendedErrors : public DBProp { 
private:
	// @cmember Static array of variations
	DECLARE_TEST_CASE_DATA();
	
public:
	// {{ TCW_DECLARE_FUNCS
	// @cmember Execution Routine
	DECLARE_TEST_CASE_FUNCS(TCExtendedErrors,DBProp);
	// }} TCW_DECLARE_FUNCS_END
 

	// @cmember Initialization Routine
	virtual BOOL Init();
	// @cmember Termination Routine
	virtual BOOL Terminate();
	
	// {{ TCW_TESTVARS()
	// @cmember Valid GetKeywords call with previous error object existing.
	int Variation_1();
	// @cmember Valid GetLiteralInfo call with previous error object existing.
	int Variation_2();
	// @cmember E_INVALIDARG GetKeywords call with previous error object existing.
	int Variation_3();
	// @cmember E_INVALIDARG GetLiteralInfo call with previous error object existing.
	int Variation_4();
	// @cmember DB_S_ERRORSOCCURRED GetLiteralInfo call with no previous error object existing.
	int Variation_5();
	// @cmember DB_E_ERRORSOCCURRED GetLiteralInfo call with no previous error object existing.
	int Variation_6();
	// }} TCW_TESTVARS_END
};

// {{ TCW_TESTCASE(TCExtendedErrors)
#define THE_CLASS TCExtendedErrors
BEG_TEST_CASE(TCExtendedErrors, DBProp, L"Extended Errors")
	TEST_VARIATION(1, 		L"Valid GetKeywords call with previous error object existing.")
	TEST_VARIATION(2, 		L"Valid GetLiteralInfo call with previous error object existing.")
	TEST_VARIATION(3, 		L"E_INVALIDARG GetKeywords call with previous error object existing.")
	TEST_VARIATION(4, 		L"E_INVALIDARG GetLiteralInfo call with previous error object existing.")
	TEST_VARIATION(5, 		L"DB_S_ERRORSOCCURRED GetLiteralInfo call with no previous error object existing.")
	TEST_VARIATION(6, 		L"DB_E_ERRORSOCCURRED GetLiteralInfo call 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(4, ThisModule, gwszModuleDescrip)
	TEST_CASE(1, Keywords)
	TEST_CASE(2, LiteralInfo)
	TEST_CASE(3, TCZOMBIE_Zombie)
	TEST_CASE(4, TCExtendedErrors)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END


// {{ TCW_TC_PROTOTYPE(Keywords)
//*-----------------------------------------------------------------------
//| Test Case:		Keywords - testing keywords
//|	Created:		06/03/96
//|	Updated:		04/25/98
//*-----------------------------------------------------------------------

//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL Keywords::Init()
{
	// {{ TCW_INIT_BASECLASS_CHECK
	return (DBProp::Init());
	// }}
}


// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Keywords::Variation_1()
{
	// Initialize
	TBEGIN;
	INIT;

	// Call with a valid pwszKeywords pointer
	TESTC_(m_hr=m_pIDBInfo->GetKeywords(&m_pwszKeywords), S_OK);
	TESTC(KeywordsVerify(m_hr));
	
CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Keywords::Variation_2()
{
	// Initialize
	TBEGIN;
	INIT;

	// Call with a NULL pwszKeywords pointer
	TESTC_(m_hr=m_pIDBInfo->GetKeywords(NULL), E_INVALIDARG);
	TESTC(KeywordsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_UNEXPECTED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int Keywords::Variation_3()
{
	// Initialize
	TBEGIN;
	INIT;
	
	// Dirty the output params
	m_pwszKeywords = INVALID(OLECHAR*);

	// Uninitialize the DSO
	TESTC_(m_pIDBInitialize->Uninitialize(), S_OK);
	
	// Call with a valid pwszKeywords pointer
	TESTC_(m_hr=m_pIDBInfo->GetKeywords(&m_pwszKeywords), E_UNEXPECTED);
	TESTC(KeywordsVerify(m_hr));
	
	// Reinitialize the DSO
	InitializeDSO(REINITIALIZE_YES);
		
CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL Keywords::Terminate()
{
	// {{ TCW_TERM_BASECLASS_CHECK2
	return(DBProp::Terminate());
}	// }}
// }}
// }}


// {{ TCW_TC_PROTOTYPE(LiteralInfo)
//*-----------------------------------------------------------------------
//| Test Case:		LiteralInfo - testing LiteralInfo
//|	Created:		06/03/96
//|	Updated:		04/25/98
//*-----------------------------------------------------------------------

//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL LiteralInfo::Init()
{
	// {{ TCW_INIT_BASECLASS_CHECK
	return (DBProp::Init());
	// }}
}


// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK - cLiterals == 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_1()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check the first valid Literal case
	ArrangeLiterals(ZERO);

	// Check the 0 cLiteral case
	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr, TRUE));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc S_OK - cLiterals == 1
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_2()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check the first valid Literal case
	ArrangeLiterals(ONE);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc S_OK - cLiterals == ALL Literals
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_3()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case
	ArrangeLiterals(ALLSUPPORTED);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG - cLiterals != 0, and rgLiterals == NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_4()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case with a NULL rgLiterals
	ArrangeLiterals(ALLSUPPORTED);

	// Dirty the output params
	m_cLiteralInfo =  INVALID(ULONG);
	m_rgLiteralInfo = INVALID(DBLITERALINFO*);
	m_pCharBuffer =   INVALID(OLECHAR*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(1, NULL,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), E_INVALIDARG);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG - pcLiteralInfo was a null pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_5()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case with a NULL pcLiteralInfo
	ArrangeLiterals(ALLSUPPORTED);

	// Dirty the output params
	m_rgLiteralInfo = INVALID(DBLITERALINFO*);
	m_pCharBuffer =   INVALID(OLECHAR*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
					NULL, &m_rgLiteralInfo, &m_pCharBuffer), E_INVALIDARG);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG - prgLiteralInfo was a null pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_6()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case with a NULL prgLiteralInfo
	ArrangeLiterals(ALLSUPPORTED);

	// Dirty the output params
	m_cLiteralInfo = INVALID(ULONG);
	m_pCharBuffer =  INVALID(OLECHAR*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
					&m_cLiteralInfo, NULL, &m_pCharBuffer), E_INVALIDARG);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG - pCharBuffer was a null pointer
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_7()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case with a NULL pCharBuffer
	ArrangeLiterals(ALLSUPPORTED);

	// Dirty the output params
	m_cLiteralInfo =  INVALID(ULONG);
	m_rgLiteralInfo = INVALID(DBLITERALINFO*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
					&m_cLiteralInfo, &m_rgLiteralInfo, NULL), E_INVALIDARG);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Half of valid literals
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_8()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check the first half of the valid Literals
	ArrangeLiterals(HALF);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}

// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Reverse of all valid literals
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_9()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all valid Literals case in reverse order
	ArrangeLiterals(ALLREVERSE);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc S_OK - rgLiterals contained at least 1 unsupported or invalid literal with cLiterals = 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_10()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check first invalid Literal case
	ArrangeLiterals(INVALID1);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(0, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc S_OK - all literals invalid or unsupported with cLiterals = 0
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_11()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all invalid Literals case
	ArrangeLiterals(INVALIDALL);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(0, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED - rgLiterals contained at least 1 unsupported or invalid literal
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_12()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check first invalid Literal case
	ArrangeLiterals(INVALID1);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals, &m_cLiteralInfo,
			&m_rgLiteralInfo, &m_pCharBuffer), (m_cLiterals ? DB_S_ERRORSOCCURRED : S_OK));
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED - all literals invalid or unsupported
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_13()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check all invalid Literals case
	ArrangeLiterals(INVALIDALL);

	// Dirty the output params
	m_pCharBuffer = INVALID(OLECHAR*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), DB_E_ERRORSOCCURRED);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}

// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc E_UNEXPECTED - Uninitialized
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_14()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check before Initializing the Provider
	TESTC_(m_pIDBInitialize->Uninitialize(), S_OK);

	// Dirty the output params
	m_cLiteralInfo =  INVALID(ULONG);
	m_rgLiteralInfo = INVALID(DBLITERALINFO*);
	m_pCharBuffer =   INVALID(OLECHAR*);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(0, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), E_UNEXPECTED);
	TESTC(LiteralsVerify(m_hr));

	// Reinitialize the DSO
	InitializeDSO(REINITIALIZE_YES);

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc S_OK - 2.x Provider has both QUOTE_PREFIX and QUOTE_SUFFIX
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_15()
{
	// Initialize
	TBEGIN;
	INIT;

	// Allocate memory and set QUOTE_PREFIX and QUOTE_SUFFIX
	SAFE_ALLOC(m_rgLiterals, DBLITERAL, 2);
	
	m_rgLiterals[0] = DBLITERAL_QUOTE_PREFIX;
	m_rgLiterals[1] = DBLITERAL_QUOTE_SUFFIX;

	TEST2C_(m_hr=m_pIDBInfo->GetLiteralInfo(2, m_rgLiterals,
			&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer),S_OK, DB_E_ERRORSOCCURRED);

	// Compare DBLITERAL_QUOTE_PREFIX and DBLITERAL_QUOTE_SUFFIX
	TESTC(m_cLiteralInfo == 2);
	TESTC(m_rgLiteralInfo[0].fSupported == m_rgLiteralInfo[1].fSupported);

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Check for both CATALOG_NAME and CATALOG_SEPARATOR
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_16()
{
	// Initialize
	TBEGIN;
	INIT;

	// Allocate memory and set CATALOG_NAME and CATALOG_SEPARATOR
	SAFE_ALLOC(m_rgLiterals, DBLITERAL, 2);
	
	m_rgLiterals[0] = DBLITERAL_CATALOG_NAME;
	m_rgLiterals[1] = DBLITERAL_CATALOG_SEPARATOR;

	TEST2C_(m_hr=m_pIDBInfo->GetLiteralInfo(2, m_rgLiterals,
			&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer),S_OK, DB_E_ERRORSOCCURRED);

	// Compare DBLITERAL_CATALOG_NAME and DBLITERAL_CATALOG_SEPARATOR
	TESTC(m_cLiteralInfo == 2);
	TESTC(m_rgLiteralInfo[0].fSupported == m_rgLiteralInfo[1].fSupported);

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc S_OK - 2.x Provider has both SCHEMA_NAME and SCHEMA_SEPARATOR
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_17()
{
	// Initialize
	TBEGIN;
	INIT;

	// Allocate memory and set SCHEMA_NAME and SCHEMA_SEPARATOR
	SAFE_ALLOC(m_rgLiterals, DBLITERAL, 2);
	
	m_rgLiterals[0] = DBLITERAL_SCHEMA_NAME;
	m_rgLiterals[1] = DBLITERAL_SCHEMA_SEPARATOR;

	TEST2C_(m_hr=m_pIDBInfo->GetLiteralInfo(2, m_rgLiterals,
			&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer),S_OK, DB_E_ERRORSOCCURRED);

	// Compare DBLITERAL_SCHEMA_NAME and DBLITERAL_SCHEMA_SEPARATOR
	TESTC(m_cLiteralInfo == 2);
	TESTC(m_rgLiteralInfo[0].fSupported == m_rgLiteralInfo[1].fSupported);

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc S_OK - cLiterals == ALL Literals multiple times
//
// @rdesc TEST_PASS or TEST_FAIL
//
int LiteralInfo::Variation_18()
{
	TBEGIN;

	// Initialize
	ULONG ulIndex = 0;
	INIT;

	// Check all valid Literals case
	ArrangeLiterals(ALLSUPPORTED);

	// Allocate memory and set Literals
	#define MAX_LITERALS 2050
	SAFE_REALLOC(m_rgLiterals, DBLITERAL, m_cLiterals*MAX_LITERALS);

	for(ulIndex=0; ulIndex < MAX_LITERALS; ulIndex++)
		memcpy(&m_rgLiterals[m_cLiterals*ulIndex],m_rgLiterals,(m_cLiterals*sizeof(DBLITERAL)));

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo((m_cLiterals * MAX_LITERALS), m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL LiteralInfo::Terminate()
{
	// {{ TCW_TERM_BASECLASS_CHECK2
	return(DBProp::Terminate());
}	// }}
// }}
// }}


// {{ TCW_TC_PROTOTYPE(TCZOMBIE_Zombie)
//*-----------------------------------------------------------------------
//| Test Case:		TCZOMBIE_Zombie - Induce zombie states
//|	Created:		02/02/96
//|	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_pIDBInfo = NULL;
	m_pITransactionLocal = INVALID(ITransactionLocal*);
	
	// {{ TCW_INIT_BASECLASS_CHECK
	if(CTransaction::Init())
	// }}
	{
		// IDBInfo
		TESTC(VerifyInterface(m_pThisTestModule->m_pIUnknown, IID_IDBInfo, 
								DATASOURCE_INTERFACE, (IUnknown**)&m_pIDBInfo));
		
		// Register Interface with Zombie
		TESTC(RegisterInterface(DATASOURCE_INTERFACE, IID_IDBInfo,0,NULL));
		return TRUE;
	}

	// Check to see if ITransaction is supported
    if( !m_pITransactionLocal )
		return TEST_SKIPPED;

    // Clear the bad pointer value
	if(m_pITransactionLocal == INVALID(ITransactionLocal*))
		m_pITransactionLocal = NULL;

CLEANUP:

	return FALSE;
}

// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Commit IDBInfo with fRetaining=TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCZOMBIE_Zombie::Variation_1()
{
	// S_OK - Commit IDBInfo with fRetaining=TRUE
	return TestTxn(ETXN_COMMIT, TRUE);
}
// }}


// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Commit IDBInfo with fRetaining=FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCZOMBIE_Zombie::Variation_2()
{
	// S_OK - Commit IDBInfo with fRetaining=FALSE
	return TestTxn(ETXN_COMMIT, FALSE);
}
// }}


// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Abort IDBInfo with fRetaining=TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCZOMBIE_Zombie::Variation_3()
{
	// S_OK - Abort IDBInfo with fRetaining=TRUE
	return TestTxn(ETXN_ABORT, TRUE);
}
// }}


// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc S_OK - Abort IDBInfo with fRetaining=FALSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCZOMBIE_Zombie::Variation_4()
{
	// S_OK - Abort IDBInfo with fRetaining=FALSE
	return TestTxn(ETXN_ABORT, FALSE);
}
// }}


// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCZOMBIE_Zombie::Terminate()
{
	// Release the Interfaces
	SAFE_RELEASE(m_pIDBInfo);

	return(CTransaction::Terminate());
}	// }}
// }}


// {{ TCW_TC_PROTOTYPE(TCExtendedErrors)
//*-----------------------------------------------------------------------
//| Test Case:		TCExtendedErrors - Extended Errors
//|	Created:		08/12/96
//|	Updated:		04/25/98
//*-----------------------------------------------------------------------

//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCExtendedErrors::Init()
{
	// {{ TCW_INIT_BASECLASS_CHECK
	return (DBProp::Init());
	// }}
}


// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Valid GetKeywords call with previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_1()
{
	// Initialize
	TBEGIN;
	INIT;

	// Cause an Error
 	m_pExtError->CauseError();

	TESTC_(m_hr=m_pIDBInfo->GetKeywords(&m_pwszKeywords),S_OK);

	// Do extended check following GetKeywords
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));
	TESTC(KeywordsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Valid GetLiteralInfo call with previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_2()
{
	// Initialize
	TBEGIN;
	INIT;

	// Cause an Error
 	m_pExtError->CauseError();
	
	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(0, m_rgLiterals,
					&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), S_OK);
	
	// Do extended check following GetLiteralInfo
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG GetKeywords call with previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_3()
{
	// Initialize
	TBEGIN;
	INIT;

	// Cause an Error
	m_pExtError->CauseError();

	TESTC_(m_hr=m_pIDBInfo->GetKeywords(NULL),E_INVALIDARG);
	
	// Do extended check following GetKeywords
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));
	TESTC(KeywordsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc E_INVALIDARG GetLiteralInfo call with previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_4()
{
	// Initialize
	TBEGIN;
	INIT;

	ArrangeLiterals(ALLSUPPORTED);

	// Cause an Error
	m_pExtError->CauseError();

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(1, NULL,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), E_INVALIDARG);

	// Do extended check following GetLiteralInfo
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
// }}


// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc DB_S_ERRORSOCCURRED GetLiteralInfo call with no previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_5()
{
	// Initialize
	TBEGIN;
	INIT;

	// Check first invalid Literal case
	ArrangeLiterals(INVALID1);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals, &m_cLiteralInfo,
			&m_rgLiteralInfo, &m_pCharBuffer), (m_cLiterals ? DB_S_ERRORSOCCURRED : S_OK));

	// Do extended check following GetLiteralInfo
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));
	TESTC(LiteralsVerify(m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
//}}


// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc DB_E_ERRORSOCCURRED GetLiteralInfo call with no previous error object existing.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCExtendedErrors::Variation_6()
{
	// Initialize
	TBEGIN;
	INIT;

	ArrangeLiterals(INVALIDALL);

	TESTC_(m_hr=m_pIDBInfo->GetLiteralInfo(m_cLiterals, m_rgLiterals,
				&m_cLiteralInfo, &m_rgLiteralInfo, &m_pCharBuffer), DB_E_ERRORSOCCURRED);

	// Do extended check following GetLiteralInfo
	TESTC(XCHECK(m_pIDBInfo, IID_IDBInfo, m_hr));

CLEANUP:
	
	TERM;
	TRETURN;
}
//}}


// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCExtendedErrors::Terminate()
{
	return (DBProp::Terminate());

}	// }}
// }}


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Verify that Keywords returned what it should have
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::KeywordsVerify(HRESULT hr)
{
	//============================================================================
	//  KEYWORDS Constants from V2.0
	//============================================================================
	const LPWSTR rgpwszKeywords[] = {
		L"ABSOLUTE",L"ACTION",L"ADD",L"ALL",L"ALLOCATE",L"ALTER",L"AND",L"ANY",L"ARE",L"AS",L"ASC",
		L"ASSERTION",L"AT",L"AUTHORIZATION",L"AVG",L"BEGIN",L"BETWEEN",L"BIT",L"BIT_LENGTH",L"BOTH",
		L"BY",L"CASCADE",L"CASCADED",L"CASE",L"CAST",L"CATALOG",L"CHAR",L"CHAR_LENGTH",L"CHARACTER",
		L"CHARACTER_LENGTH",L"CHECK",L"CLOSE",L"COALESCE",L"COLLATE",L"COLLATION",L"COLUMN",
		L"COMMIT",L"CONNECT",L"CONNECTION",L"CONSTRAINT",L"CONSTRAINTS",L"CONTINUE",L"CONVERT",
		L"CORRESPONDING",L"COUNT",L"CREATE",L"CROSS",L"CURRENT",L"CURRENT_DATE",L"CURRENT_TIME",
		L"CURRENT_TIMESTAMP",L"CURRENT_USER",L"CURSOR",L"DATE",L"DAY",L"DEALLOCATE",L"DEC",
		L"DECIMAL",L"DECLARE",L"DEFAULT",L"DEFERRABLE",L"DEFERRED",L"DELETE",L"DESC",L"DESCRIBE",
		L"DESCRIPTOR",L"DIAGNOSTICS",L"DISCONNECT",L"DISTINCT",L"DISTINCTROW",L"DOMAIN",L"DOUBLE",
		L"DROP",L"ELSE",L"END",L"END-EXEC",L"ESCAPE",L"EXCEPT",L"EXCEPTION",L"EXEC",L"EXECUTE",
		L"EXISTS",L"EXTERNAL",L"EXTRACT",L"FALSE",L"FETCH",L"FIRST",L"FLOAT",L"FOR",L"FOREIGN",
		L"FOUND",L"FROM",L"FULL",L"GET",L"GLOBAL",L"GO",L"GOTO",L"GRANT",L"GROUP",L"HAVING",L"HOUR",
		L"IDENTITY",L"IMMEDIATE",L"IN",L"INDICATOR",L"INITIALLY",L"INNER",L"INPUT",L"INSENSITIVE",
		L"INSERT",L"INT",L"INTEGER",L"INTERSECT",L"INTERVAL",L"INTO",L"IS",L"ISOLATION",L"JOIN",
		L"KEY",L"LANGUAGE",L"LAST",L"LEADING",L"LEFT",L"LEVEL",L"LIKE",L"LOCAL",L"LOWER",L"MATCH",L"MAX",
		L"MIN",L"MINUTE",L"MODULE",L"MONTH",L"NAMES",L"NATIONAL",L"NATURAL",L"NCHAR",L"NEXT",L"NO",
		L"NOT",L"NULL",L"NULLIF",L"NUMERIC",L"OCTET_LENGTH",L"OF",L"ON",L"ONLY",L"OPEN",L"OPTION",
		L"OR",L"ORDER",L"OUTER",L"OUTPUT",L"OVERLAPS",L"PARTIAL",L"POSITION",L"PRECISION",L"PREPARE",
		L"PRESERVE",L"PRIMARY",L"PRIOR",L"PRIVILEGES",L"PROCEDURE",L"PUBLIC",L"READ",L"REAL",
		L"REFERENCES",L"RELATIVE",L"RESTRICT",L"REVOKE",L"RIGHT",L"ROLLBACK",L"ROWS",L"SCHEMA",
		L"SCROLL",L"SECOND",L"SECTION",L"SELECT",L"SESSION",L"SESSION_USER",L"SET",L"SIZE",L"SMALLINT",
		L"SOME",L"SQL",L"SQLCODE",L"SQLERROR",L"SQLSTATE",L"SUBSTRING",L"SUM",L"SYSTEM_USER",L"TABLE",
		L"TEMPORARY",L"THEN",L"TIME",L"TIMESTAMP",L"TIMEZONE_HOUR",L"TIMEZONE_MINUTE",L"TO",
		L"TRAILING",L"TRANSACTION",L"TRANSLATE",L"TRANSLATION",L"TRIGGER",L"TRIM",L"TRUE",L"UNION",
		L"UNIQUE",L"UNKNOWN",L"UPDATE",L"UPPER",L"USAGE",L"USER",L"USING",L"VALUE",L"VALUES",L"VARCHAR",
		L"VARYING",L"VIEW",L"WHEN",L"WHENEVER",L"WHERE",L"WITH",L"WORK",L"WRITE",L"YEAR",L"ZONE",
	};

	ULONG ulErrors = 0;
	ULONG ulSpaces = 0;
	ULONG ulExtra  = 0;

	// If HRESULT is a failure code
	if((FAILED(hr)) && (!m_pwszKeywords))
		return TRUE;

	// If HRESULT is a success code
	if(SUCCEEDED(hr))
	{
		// It is legal to return a NULL on S_OK
		if(!m_pwszKeywords) {
			odtLog << L"The Provider returned no Keywords." <<ENDL;
			return TRUE;
		}
		
		// Check the number of commas
		for(ULONG ulIndex=0; *(m_pwszKeywords+ulIndex); ulIndex++)
		{
			if(*(m_pwszKeywords+ulIndex) == ',')
				ulExtra++;
		}
		
		// Find the first keyword and loop thru all the Keywords
		WCHAR * wtoken = wcstok(m_pwszKeywords, L",");
		
		// It is illegal to return a empty string on S_OK
		if(!wtoken) {
			odtLog << L"The Provider should of returned a NULL instead of <EMPTY> for pwszKeywords." <<ENDL;
			return FALSE;
		}

		// Loop thru all the Keywords
		while(wtoken)
		{
			// Static Keywords should not be in the list
			for(ULONG i=0; i < (sizeof(rgpwszKeywords)/sizeof(rgpwszKeywords[0])); i++)
			{
				if(!(_wcsicmp(rgpwszKeywords[i], wtoken))) {
					odtLog<<ENDL <<rgpwszKeywords[i] 
						<<L" should not be returned in the list." <<ENDL;
					ulErrors++;
				} 
			}

			// Check for leading and trailing spaces
			if( (*wtoken == L' ') || (*(wtoken + (wcslen(wtoken)-1)) == L' ') )
				ulSpaces++;

			// Print the current and get the next keyword
			odtLog <<wtoken;
			wtoken = wcstok(NULL, L",");
			wtoken ? odtLog <<L"," : odtLog <<ENDL;

			// Subtract one if another keyword
			if(wtoken)
				ulExtra--;
		}

		// Check for leading or trailing spaces
		if(ulSpaces)
			odtLog <<L"The provider had leading or trailing spaces on the keywords." <<ENDL;

		// Check for leading or trailing spaces
		if(ulExtra)
			odtLog <<L"The provider had an extra comma in the keywords list." <<ENDL;

		// If no Keywords were in the list and
		// no leading or trailing spaces return TRUE
		if(!ulErrors && !ulSpaces && !ulExtra)
			return TRUE;
	}
	
	return FALSE;
}


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Arrange Literals
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::ArrangeLiterals(ARRANGELITERAL eArrangeLiteral)
{
	ULONG ulIndex = 0;

	// Get all valid Literals
	if(FAILED(m_pIDBInfo->GetLiteralInfo(0, NULL, 
							&m_cLiterals, &m_rgLiteralInfo, &m_pCharBuffer)))
		return FALSE;

	// Check to see if we got Literals 
	if((!m_cLiterals) && (eArrangeLiteral != INVALIDALL)) {
		odtLog << L"Provider did not return any supported Literals." <<ENDL;
		return TRUE;
	}

	// Create the default returned by GetLiterals
	m_rgLiterals = (DBLITERAL *)PROVIDER_ALLOC(sizeof(DBLITERAL) * max(m_cLiterals,MAX_DBLITERALINFO));
	
	for(ulIndex=0; ulIndex < m_cLiterals; ulIndex++)
		m_rgLiterals[ulIndex] = m_rgLiteralInfo[ulIndex].lt;

	// Allocate the memory for the Literal
	switch(eArrangeLiteral)
	{
		// No Literals
		case ZERO:
			m_cLiterals = 0;
			break;

		// First supported Literal
		case ONE:
			m_cLiterals = 1;
			break;

		// First half of the supported Literals
		case HALF:
			m_cLiterals = (m_cLiterals / 2);
			break;

		// ALL supported Literals
		case ALLSUPPORTED:
			break;

		// ALL Literals in the V2.0 ENUM (DBLITERAL_INVALID -> DBLITERAL_QUOTE_SUFFIX)
		case INVALID1:
			m_cLiterals = MAX_DBLITERALINFO;
			for(ulIndex=DBLITERAL_INVALID; ulIndex <= DBLITERAL_QUOTE_SUFFIX; ulIndex++)
				m_rgLiterals[ulIndex] = ulIndex;
			break;

		// ALL unsupported Literals
		case INVALIDALL:
			m_cLiterals = MAX_DBLITERALINFO;
			for(ulIndex=0; ulIndex < MAX_DBLITERALINFO; ulIndex++)
				m_rgLiterals[ulIndex] = DBLITERAL_INVALID;
			break;

		// ALL supported Literals in reverse order
		case ALLREVERSE:
			for(ulIndex=0; ulIndex < m_cLiterals; ulIndex++)
				m_rgLiterals[ulIndex] = m_rgLiteralInfo[(m_cLiterals-ulIndex)-1].lt;
			break;

		default:
			odtLog << L"ArrangeLiterals used incorrectly" <<ENDL;
			break;
	}

	// Should never hit this since we asked for all LiteralInfos
	PROVIDER_FREE(m_rgLiteralInfo);
	PROVIDER_FREE(m_pCharBuffer);
	
 	return FALSE;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Verify that GetLiteralInfo returned what it should have
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BOOL DBProp::LiteralsVerify(HRESULT hr, BOOL fToScreen)
{
	//============================================================================
	//  LITERALS Constants from V2.0
	//============================================================================
	const LPWSTR rgpwszLiterals[] = {
		L"DBLITERAL_INVALID",L"DBLITERAL_BINARY_LITERAL",L"DBLITERAL_CATALOG_NAME",
		L"DBLITERAL_CATALOG_SEPARATOR",L"DBLITERAL_CHAR_LITERAL",L"DBLITERAL_COLUMN_ALIAS",
		L"DBLITERAL_COLUMN_NAME",L"DBLITERAL_CORRELATION_NAME",L"DBLITERAL_CURSOR_NAME",
		L"DBLITERAL_ESCAPE_PERCENT_PREFIX",L"DBLITERAL_ESCAPE_UNDERSCORE_PREFIX",
		L"DBLITERAL_INDEX_NAME",L"DBLITERAL_LIKE_PERCENT",L"DBLITERAL_LIKE_UNDERSCORE",
		L"DBLITERAL_PROCEDURE_NAME",L"DBLITERAL_QUOTE_PREFIX",L"DBLITERAL_SCHEMA_NAME",
		L"DBLITERAL_TABLE_NAME",L"DBLITERAL_TEXT_COMMAND",L"DBLITERAL_USER_NAME",
		L"DBLITERAL_VIEW_NAME",L"DBLITERAL_CUBE_NAME",L"DBLITERAL_DIMENSION_NAME",
		L"DBLITERAL_HIERARCHY_NAME",L"DBLITERAL_LEVEL_NAME",L"DBLITERAL_MEMBER_NAME",
		L"DBLITERAL_PROPERTY_NAME",L"DBLITERAL_SCHEMA_SEPARATOR",L"DBLITERAL_QUOTE_SUFFIX",
		L"DBLITERAL_ESCAPE_PERCENT_SUFFIX",L"DBLITERAL_ESCAPE_UNDERSCORE_SUFFIX"
	};

	BOOL  fSucceed	    = FALSE;
	ULONG errors	    = 0;
	ULONG ulSupported   = 0;
	
	// Check the pointers to see if they are updated
	if( (m_cLiteralInfo  == INVALID(ULONG)) || 
		(m_rgLiteralInfo == INVALID(DBLITERALINFO*)) || 
		(m_pCharBuffer   == INVALID(OLECHAR*)) )
		return FALSE;

	// If HRESULT is a E_CODE other than DB_E_ERRORSOCCURRED
	// or HRESULT is S_OK and 0 Literals where supported
	if( (((FAILED(hr)) && (hr != DB_E_ERRORSOCCURRED)) || (hr == S_OK)) && 
		(!m_cLiteralInfo) && (!m_rgLiteralInfo) && (!m_pCharBuffer) )
		return TRUE;

	// If the count of literals is > 0
	if(m_cLiteralInfo)
	{
		// Count the supported Literals
		for(ULONG i=0; i < m_cLiteralInfo; i++)
			if(m_rgLiteralInfo[i].fSupported)
				ulSupported++;

		// All supported
		if(hr == S_OK)
			COMPARE(m_cLiteralInfo, ulSupported);
		
		// Atleast 1 unsupported
		if(hr == DB_S_ERRORSOCCURRED)
			COMPARE(((m_cLiteralInfo > ulSupported) && ulSupported), TRUE);
		
		// Atleast 1 unsupported
		if(hr == DB_E_ERRORSOCCURRED)
			COMPARE((!ulSupported && m_rgLiteralInfo), TRUE);

		// Check the pCharBuffer, it should be NULL on ERROR
		if(SUCCEEDED(hr))
			COMPARE(!m_pCharBuffer, NULL);
		else
			COMPARE(m_pCharBuffer, NULL);

		// Check the Data returned
		for(ULONG ulIndex=0; ulIndex < m_cLiteralInfo; ulIndex++)
		{
			// Check for unsupported Literals
			if(!(m_rgLiteralInfo[ulIndex].fSupported))
			{
				// Everything should be NULL or 0
				COMPARE(((m_rgLiteralInfo[ulIndex].pwszLiteralValue) ||
						 (m_rgLiteralInfo[ulIndex].pwszInvalidChars) ||
						 (m_rgLiteralInfo[ulIndex].pwszInvalidStartingChars) ||
						 (m_rgLiteralInfo[ulIndex].cchMaxLen)), FALSE);

				continue;
			}

			// These are the only 8 that should modify pwszLiteralValue and cchMaxLen, 
			// and not modify pwszInvalidChar and pwszInvalidStartingChar.
			if( (m_rgLiteralInfo[ulIndex].lt == DBLITERAL_CATALOG_SEPARATOR)		||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_ESCAPE_PERCENT_PREFIX)    ||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_ESCAPE_PERCENT_SUFFIX)    ||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_ESCAPE_UNDERSCORE_PREFIX)	||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_ESCAPE_UNDERSCORE_SUFFIX)	||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_LIKE_PERCENT)				||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_LIKE_UNDERSCORE)			||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_QUOTE_PREFIX)				||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_QUOTE_SUFFIX)				||
				(m_rgLiteralInfo[ulIndex].lt == DBLITERAL_SCHEMA_SEPARATOR) )
			{
				// Check pwszLiteralValue exceptions 
				if(!m_rgLiteralInfo[ulIndex].pwszLiteralValue)
				{
					odtLog << L"ERROR: pwszLiteralValue exceptions:  ";
					odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
					odtLog << L" should not be NULL." <<ENDL;
					errors++;
				}

				// Check pwszInvalidChar exceptions
				if(m_rgLiteralInfo[ulIndex].pwszInvalidChars)
				{
					odtLog << L"ERROR: pwszInvalidChars exceptions:  ";
					odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
					odtLog << L" should be NULL." <<ENDL;
					errors++;
				}

				// Check pwszInvalidStartingChar exceptions
				if(m_rgLiteralInfo[ulIndex].pwszInvalidStartingChars)
				{
					odtLog << L"ERROR: pwszInvalidStartingChars exceptions:  ";
					odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
					odtLog << L" should be NULL." <<ENDL;
					errors++;
				}

				// Check cchMaxLen exceptions
				if( (m_rgLiteralInfo[ulIndex].pwszLiteralValue) && 
					(m_rgLiteralInfo[ulIndex].cchMaxLen != wcslen(m_rgLiteralInfo[ulIndex].pwszLiteralValue)) )
				{
					odtLog << L"ERROR: cchMaxLen exceptions:  ";
					odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
					odtLog << L" expect " << (ULONG) wcslen(m_rgLiteralInfo[ulIndex].pwszLiteralValue)
						<< 	L" but returned " << m_rgLiteralInfo[ulIndex].cchMaxLen 
						<< 	L" charcters." << ENDL;
					errors++;
				}
			}
			else if(m_rgLiteralInfo[ulIndex].pwszLiteralValue)
			{
				odtLog << L"ERROR: pwszLiteralValue exceptions:  ";
				odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
				odtLog << L" should be NULL." <<ENDL;
				errors++;
			}

			// Nothing should return 0, should be ~0
			if(!m_rgLiteralInfo[ulIndex].cchMaxLen && fToScreen)
			{
				odtLog << L"ERROR: cchMaxLen exceptions:  ";
				odtLog << rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt];
				odtLog << L" should not be 0, should be ~0." <<ENDL;
				errors++;
			}

			// Print the data to the screen
			if(fToScreen)
			{
				odtLog << L"[" <<ulIndex << L"]:DBLITERAL = "
						<< rgpwszLiterals[m_rgLiteralInfo[ulIndex].lt] <<ENDL; 
				
				odtLog << L"[" <<ulIndex << L"]:pwszLiteralValue = "; 
				if(m_rgLiteralInfo[ulIndex].pwszLiteralValue)
					odtLog << m_rgLiteralInfo[ulIndex].pwszLiteralValue <<ENDL;
				else
					odtLog << L"<null>" <<ENDL;

				odtLog << L"[" <<ulIndex << L"]:pwszInvalidChars = ";
				if(m_rgLiteralInfo[ulIndex].pwszInvalidChars)
					odtLog << m_rgLiteralInfo[ulIndex].pwszInvalidChars <<ENDL;
				else
					odtLog << L"<null>" <<ENDL;

				odtLog << L"[" << ulIndex << L"]:pwszInvalidStartingChars = ";
				if(m_rgLiteralInfo[ulIndex].pwszInvalidStartingChars)
					odtLog << m_rgLiteralInfo[ulIndex].pwszInvalidStartingChars <<ENDL;
				else
					odtLog << L"<null>" <<ENDL;

				odtLog << L"[" << ulIndex << L"]:fSupported = "
					<< m_rgLiteralInfo[ulIndex].fSupported <<ENDL; 
				odtLog << L"[" << ulIndex << L"]:cchMaxLen = "
					<< m_rgLiteralInfo[ulIndex].cchMaxLen <<ENDL; 
				odtLog << L"_________________________________________________" << ENDL;
			}
		}
		
		if(!errors)
			fSucceed = TRUE;
	}
		
	return fSucceed;
}


//--------------------------------------------------------------------
// @mfunc Test Zombie cases
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCZOMBIE_Zombie::TestTxn(ETXN eTxn, BOOL fRetaining)
{
	TBEGIN;

	HRESULT		ExpectedHr		= E_UNEXPECTED;	// Expected HRESULT
	DBCOUNTITEM	cRowsObtained	= 0;			// Number of rows returned, should be 1
	HROW *		rghRows			= NULL;			// Array of Row Handles
	IDBInfo *	pIDBInfo		= NULL;			// IDBInfo object
	LPWSTR		pwszKeywords	= NULL;			// List of Keywords
	ULONG 		cLiteralInfo	= 0;			// Number of Literals
	WCHAR *		pCharBuffer		= NULL;			// Character buffer
	DBLITERALINFO *	rgLiteralInfo = NULL;		// Array of Literals

	// Retrieve an Interface pointer to IDBInfo within a Transaction
	TESTC(StartTransaction(SELECT_ALLFROMTBL, (IUnknown**)&pIDBInfo));

	// 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) && (!GetCommit(fRetaining))) ||
	    ((eTxn == ETXN_ABORT)  && (!GetAbort(fRetaining))) )
		goto CLEANUP;

	// Test zombie
	TESTC_(m_pIRowset->GetNextRows(0,0,1,&cRowsObtained,&rghRows), ExpectedHr);
		
	// Make sure that this Interface is unaffected
	TESTC_(m_pIDBInfo->GetKeywords(&pwszKeywords),S_OK);

	// Make sure that this Interface is unaffected
	TESTC_(m_pIDBInfo->GetLiteralInfo(0, NULL,
				&cLiteralInfo, &rgLiteralInfo, &pCharBuffer), S_OK);

CLEANUP:
	
	// Release the row handle on the 1st rowset
	CHECK(m_pIRowset->ReleaseRows(cRowsObtained, rghRows, NULL, NULL, NULL), S_OK);
	PROVIDER_FREE(rghRows);

	// Release the IDBInfo
	SAFE_RELEASE(pIDBInfo);
	
	PROVIDER_FREE(pwszKeywords);
 	PROVIDER_FREE(rgLiteralInfo);
	PROVIDER_FREE(pCharBuffer);

	// Cleanup Transactions
	CleanUpTransaction(fRetaining ? S_OK : XACT_E_NOTRANSACTION);

	TRETURN;
}