// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // These macros and templates extend the tef testsuite support.

 // 

 //

 /**

  @file

  @test

  @internalComponent - Internal Symbian test code

 */

 #ifndef __EXTENDTEF_H__

 #define __EXTENDTEF_H__

 #include <test/tefunit.h>

 // Adds a test suite that is not called CreateSuiteL so that one class can describe multiple subsets of tests.

 #define ADD_TEST_SUITE_SUB(subname) \

 	_LIT( KTest ## subname, #subname); \

 	lTestSuite->AddL( CreateSuiteSub##subname##L( KTest##subname));

 // Calls a subfunction to add more members to the current test suite at the current level. Can be the same function as used to create nested tests.

 #define ADD_TEST_SUITE_SUB_FLAT(subname) \

 	_LIT( KTest ## subname, #subname); \

 	CreateSuiteSub##subname##L( KTest##subname,lTestSuite);

 // Allows the class suite to be added with a name different to the class name, so class names can be computational

 #define ADD_TEST_SUITE_MODULE_SUB_AS(module,subname,as) \

 	_LIT( KTest ## as, #as); \

 	lTestSuite->AddL( module::CreateSuiteSub##subname##L( KTest##as));

 /** Use in a subsuite to distinguish between ADD_TEST_SUITE_SUB and ADD_TEST_SUITE_SUB_FLAT caller

  *	ClassName is required - it defines the name of the class containing the referenced methods. 

  *	aTestSuite is optional - it should be the function parameter aTestSuite or the keyword NULL 

  **/

 #define SUB_SUITE_OPT(ClassName,aTestSuite) \

 	CTestSuite* lTestSuite = aTestSuite? (CTestSuite*)aTestSuite: CTestSuite::NewL(aName); \

 	typedef ClassName	ThisThis;

 // Create a dotted name subtest in the script that represents a parameter to the named test

 // This should be called from a ADD_TEST_SUITE_SUB with the same name as the test method,

 // so that entries can be inserted of the form CMyTestClass.MyTest.EColor256

 #define ADD_TEST_STEP_PARAM_1(method,param)	\

 	_LIT( KTest ## method ## param, #param); \

 	AddTestCaseParam(lTestSuite, KTest ## method ## param, method, param);

 // Insert a test that takes a parameter and a range of dotted subtests that set that parameter

 // This allows tests of the form CMyTestClass.MyLoopTest.8

 #define ADD_TEST_STEP_PARAM_RANGE(method,minparam,maxparam)	\

 	_LIT(KTest ## method,#method); \

 	AddTestCaseParamRangeL(lTestSuite,KTest ## method,&ThisThis::method,minparam,maxparam);

 // Insert a test that takes a parameter and a range of dotted subtests that set that parameter

 // This allows tests of the form CMyTestClass.MyLoopTest.8

 #define ADD_TEST_STEP_PARAM_RANGE_STEP(method,minparam,maxparam,step)		 \

 	_LIT( KTest ## method , #method); \

 	AddTestCaseParamRangeL(lTestSuite, KTest ## method, &ThisThis::method, minparam,maxparam,step);

 // Insert a test that takes a boolean parameter and a range of dotted subtests that set that parameter 

 // Names for dotted tests include "true", "yes", "on", "1"

 // This allows tests of the form CMyTestClass.EnableFeature.on

 #define ADD_TEST_STEP_PARAM_BOOL(method)	\

 	_LIT(KTest ## method,#method); \

 	AddTestCaseParamBoolL(lTestSuite,KTest ## method,&ThisThis::method);

 // Insert a test that that just requires calling a function

 #define ADD_WSGCE_TEST_STEP(classname,method) \

 	_LIT(KTest ## method,#method); \

 	AddTestCase(lTestSuite,KTest ## method,&classname::method);

 // Insert an asyncronus test that that just requires calling a function

 #define ADD_WSGCE_ASYNC_TEST_STEP(classname,method) \

 	_LIT(KTest ## method,#method); \

 	AddAsyncTestCase(lTestSuite,KTest ## method,&classname::method);

 // Insert a test that that just requires calling a function

 #define ADD_THIS_TEST_STEP(method) \

 	_LIT(KTest ## method,#method); \

 	AddTestCase(lTestSuite,KTest ## method,&ThisThis::method);

 // Insert an asyncronus test that that just requires calling a function

 #define ADD_THIS_ASYNC_TEST_STEP(method) \

 	_LIT(KTest ## method,#method); \

 	AddAsyncTestCase(lTestSuite,KTest ## method,&ThisThis::method);

 /*********************************************************************************

  * Base class for derived doers that use the Setup/Shutdown

  *********************************************************************************/

 template <class Fixture>

 class CTestCaseDoTemplate : public CTestCase

 	{

 private:

 public:

 	CTestCaseDoTemplate(const TDesC &aName);

 	virtual ~CTestCaseDoTemplate();

 	virtual void RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger);

 	virtual void DoRunL(Fixture*aFixture)=0;

 protected:

 	};

 /*********************************************************************************

  * Derived dorun to run a test with a parameter

  *********************************************************************************/

 template <class Fixture,class Param>

 class CTestCaseParamTemplate : public CTestCaseDoTemplate<Fixture>

 	{

 private:

 	typedef void (Fixture::*TestMethod)(Param aParam);

 public:

 	CTestCaseParamTemplate(const TDesC &aName, TestMethod aTestMethod, Param aParam)

 	:	CTestCaseDoTemplate<Fixture>(aName),

 		iTest(aTestMethod),iParam(aParam)

 	{}

 	virtual void DoRunL(Fixture*aFixture)

 		{

 		(aFixture->*iTest)(iParam);

 		}

 protected:

 	TestMethod	iTest;

 	Param iParam;

 	};

 /***************************************

  * 

  * Implementation of template <class Fixture,class Param> class CTestCaseTemplate

  *

  ***************************************/

 template <class Fixture>

 CTestCaseDoTemplate<Fixture>::CTestCaseDoTemplate(const TDesC &aName)

 : CTestCase(aName)

 	{

 	}

 template <class Fixture>

 CTestCaseDoTemplate<Fixture>::~CTestCaseDoTemplate()

 	{

 	}

 template <class Fixture>

 void CTestCaseDoTemplate<Fixture>::RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger)

 /**

  * Creates and destroys the test fixture, but runs the DoRunL in the derived class, which in turn runs the test. 

  *

  * @param aConfig - Test configuration

  * @param aLogger - Test logger

  */

 	{

 	Fixture* iFixture = new (ELeave) Fixture();

 	CleanupStack::PushL(iFixture);

 	// Must set the Logger and Config now

 	iFixture->SetLoggerL( aLogger );

 	iFixture->SetConfigL( aConfig );

 	// Setup code

 	iFixture->SetupL();

 	// Run the test

 	TRAPD( err, DoRunL(iFixture) );

 	// Log the result

 	CTEFLogger::LogResult( iName, err, aLogger );

 	// Now the test case has been logged we need to leave

 	// again if that is what the test did

 	if( err != KErrTEFUnitPass )

 		{

 		User::Leave(err);

 		}

 	// Teardown code

 	iFixture->TearDownL();

 	CleanupStack::PopAndDestroy();

 	}

 /**

  * Support method to add a test that takes a specific value as its parameter.

  * Can be used from ADD_TEST_STEP_PARAM_1, or from the methods below

  **/

 template <class Param,class Fixture>

 inline void AddTestCaseParam(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam),Param aParam)

 	{

 	CTestCaseParamTemplate<Fixture,Param> *testCaseTemplate = new (ELeave) CTestCaseParamTemplate<Fixture,Param>(aName, aTestMethod,aParam);

 	CleanupStack::PushL(testCaseTemplate);

 	aTestSuite->AddL( testCaseTemplate );

 	CleanupStack::Pop(testCaseTemplate);

 	}

 /**

  * Adds a test with a range of parameter values. Usually launched from ADD_TEST_STEP_PARAM_RANGE

  * 

  **/

 template <class Param,class Fixture>

 inline void AddTestCaseParamRangeL(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam),TInt aParamMin,TInt aParamMax,TInt aDelta=1)

 	{

 	CTestSuite* lTestSuite = CTestSuite::NewL(aName);

 	CleanupStack::PushL(lTestSuite);

 	__ASSERT_ALWAYS(aDelta!=0 && aParamMin!=aParamMax,User::Invariant());

 	__ASSERT_ALWAYS((aDelta>0) == (aParamMax>aParamMin),User::Invariant());

 	for (TInt count=aParamMin;count!=aParamMax;count+=aDelta)

 		{

 		TBuf<10> name2;

 		name2.AppendNum(count);

 		CTestCaseParamTemplate<Fixture,Param> *testCaseTemplate = new (ELeave) CTestCaseParamTemplate<Fixture,Param>(name2, aTestMethod,Param(count));

 		CleanupStack::PushL(testCaseTemplate);

 		lTestSuite->AddL( testCaseTemplate );

 		CleanupStack::Pop(testCaseTemplate);

 		}

 	aTestSuite->AddL(lTestSuite);

 	CleanupStack::Pop(lTestSuite);

 	}

 /**

  * Adds a test with a range of parameter values. Usually launched from ADD_TEST_STEP_PARAM_BOOL

  * 

  **/

 template <class Param,class Fixture>

 inline void AddTestCaseParamBoolL(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam))

 	{

 	class CTestSuiteBool: public CTestSuite

 		{

 		public:

 		static CTestSuite* NewL(const TTestName& aName)

 			{

 			CTestSuite* lTestSuite = new (ELeave) CTestSuiteBool(aName);

 			CleanupStack::PushL(lTestSuite);

 			lTestSuite->ConstructL();

 			CleanupStack::Pop();

 			return lTestSuite;

 			}

 		protected:

 		CTestSuiteBool(const TTestName& aName):	CTestSuite(aName)

 			{	}

 		virtual void RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger)

 			{	//run "all the tests"

 			// Log that the runner is currently in this suite

 			CTEFLogger::LogTraverse( iName, aLogger );

 			TInt lError=KErrNone;

 			for(TInt lIndex = 0; lIndex < Count() && lIndex<2; lIndex++)

 				{

 				TRAPD(err,TestL(lIndex)->RunL(aConfig, aLogger));

 				if(err != KErrTEFUnitPass)

 					{

 					lError=err;

 					}

 				}

 			if(lError != KErrTEFUnitPass)

 				{

 				User::Leave(lError);

 				}

 			}

 		};

 	typedef Fixture	ThisThis;

 	CTestSuite* lTestSuite = CTestSuiteBool::NewL(aName);

 	CleanupStack::PushL(lTestSuite);

 #define yes 1

 #define true 1

 #define on 1

 #define off 0

 #define no 0

 #define false 0

 #define Yes 1

 #define True 1

 #define On 1

 #define Off 0

 #define No 0

 #define False 0

 #define YES 1

 #define ON 1

 #define OFF 0

 #define NO 0

 #define ETrue 1

 #define EFalse 0

 	//The first two MUST be a true and a false so running "all" will run them both

 	ADD_TEST_STEP_PARAM_1(aTestMethod,ETrue);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,EFalse);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,1);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,0);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,yes);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,true);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,on);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,no);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,false);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,off);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,Yes);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,True);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,On);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,No);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,False);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,Off);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,YES);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,TRUE);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,ON);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,NO);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,FALSE);

 	ADD_TEST_STEP_PARAM_1(aTestMethod,OFF);

 #undef yes 

 #undef true

 #undef on 

 #undef off

 #undef no 

 #undef false

 #undef Yes

 #undef True

 #undef On

 #undef Off

 #undef No

 #undef False

 #undef YES

 #undef ON

 #undef OFF

 #undef NO

 #undef ETrue

 #undef EFalse

 	aTestSuite->AddL(lTestSuite);

 	CleanupStack::Pop(lTestSuite);

 	}

 void TefUnitFailLeaveL();

 #undef 	__ASSERT_SHARED

 #define __MAKE_L_STRING(S)	L##S

 /**

  * Redefining this macro allows the condition text of the assert to be logged when the fail is reported as well as the file and line number

  * This allows simple issues to be diagnosed without resorting to the source.

  **/

 #define __ASSERT_SHARED(aFunction, aMessage) \

 	if(!aFunction) \

 		{ \

 		struct Log	\

 			{	/*This wrapper is provided purely to hide the temp string from the debugger.*/ \

 			static const TLitC<sizeof("ASSERT FAILED: " #aFunction)>&	Str()\

 				{\

 				_LIT(aMessage, "ASSERT FAILED: " __MAKE_L_STRING(#aFunction) ); \

 				return aMessage;\

 				}\

 			};\

 		Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrAll, Log::Str() );\

 		TefUnitFailLeaveL();\

 		}

 #define ASSERT_NOT_EQUALS(aExpected, aActual) \

 	__ASSERT_SHARED(!AssertEquals(aExpected, aActual) , KAssertFailedEquals);

 template <class Pointer>

 inline TBool AssertTrue(Pointer* aCondition)

 	{

 	return AssertTrue((TBool)aCondition);

 	}

 #define LOG_AND_RETURN_IF_GOT_GCE										\

 		{																\

 		if (GCEIsSupported())											\

 			{															\

 			INFO_PRINTF1(_L("Test skipped: GCE support is loaded"));	\

 			User::Panic(_L("GCE.Wrong.Mode"),1);						\

 			return;														\

 			}															\

 		}

 #define LOG_AND_PANIC_IF_NOT_GCE											\

 		{																	\

 		if (!GCEIsSupported())												\

 			{																\

 			INFO_PRINTF1(_L("Test skipped: GCE support is not loaded"));	\

 			User::Panic(_L("GCE.Wrong.Mode"),1);							\

 			return;															\

 			}																\

 		}

 #define _LIT2(NAME,STRING)											\

     class NAME														\

     	{															\

     public:															\

     	static const TLitC<sizeof(L##STRING)/2>& S()			\

     		{														\

     		_LIT(singleton,STRING);								\

     		return singleton;										\

     		}														\

     	}	;

 #endif	//__EXTENDTEF_H__